API Documentation

GraphQL is a powerful query language that makes your data accessible through an API. It enables your applications to ask for specific fields on a filtered set of objects and returns only the data that is requested with minimal overhead. Read more about the benefites of GraphQL on our developer hub. There you will find tutorials, guides, tipps, and complex example queries.

Contact

API Support

support@machinemetrics.com

https://support.machinemetrics.com/hc/en-us

API Endpoints

https://api.machinemetrics.com/graphql

Headers

Authorization: Bearer <YOUR API KEY>

Authentication

The MachineMetrics GraphQL API is read-only. To interact with the API, you must have credentials. You can find a detailed example of how to set up authentication in our Getting Started Section.

Global Limits

To provide the best service availability and performance for all of our customers, we enforce API usage limits:

The maximum number of requests per minute and company is 1000.
The maximum query time is 10 seconds.
The returned JSON object cannot be more than three nesting levels deep (top level counting as level 1).
The total number of nodes (= queries + subqueries) cannot exceed 5.

Queries

`activities`

Response

Returns [Activity!]!

Arguments

Name	Description
`distinct_on` - `[ActivityField!]`	Return a distinct set of entities, defined by the given fields.
`limit` - `Int`	Limits the number of objects returned.
`offset` - `Int`	Start a the specified, zero-based array index. This is only useful in combination with `order_by`.
`order_by` - `[ActivityOrderByClause!]`	Sort the returned array by one or more fields of it's elements.
`where` - `ActivityWhereClause`	Filter the data by using a (nested) boolean expression.

Example

Query

query Activities(
  $distinct_on: [ActivityField!],
  $limit: Int,
  $offset: Int,
  $order_by: [ActivityOrderByClause!],
  $where: ActivityWhereClause
) {
  activities(
    distinct_on: $distinct_on,
    limit: $limit,
    offset: $offset,
    order_by: $order_by,
    where: $where
  ) {
    activityRef
    activitySet {
      ...ActivitySetFragment
    }
    activityType {
      ...ActivityTypeFragment
    }
    endAt
    startAt
  }
}

Variables

{
  "distinct_on": ["activityRef"],
  "limit": 987,
  "offset": 123,
  "order_by": [ActivityOrderByClause],
  "where": ActivityWhereClause
}

Response

{
  "data": {
    "activities": [
      {
        "activityRef": 982312,
        "activitySet": ActivitySet,
        "activityType": ActivityType,
        "endAt": "2022-05-07T01:08:03.420Z",
        "startAt": "2022-05-07T01:08:03.420Z"
      }
    ]
  }
}

Queries

`activitySet`

Response

Returns an ActivitySet

Arguments

Name	Description
`activitySetRef` - `bigint!`	A unique, numeric identifier for the activitySet.

Example

Query

query ActivitySet($activitySetRef: bigint!) {
  activitySet(activitySetRef: $activitySetRef) {
    activities {
      ...ActivityFragment
    }
    activitySetRef
    machine {
      ...MachineTPFragment
    }
    operation {
      ...OperationFragment
    }
    workOrderId
  }
}

Variables

{"activitySetRef": 982312}

Response

{
  "data": {
    "activitySet": {
      "activities": [Activity],
      "activitySetRef": 982312,
      "machine": MachineTP,
      "operation": Operation,
      "workOrderId": "xyz789"
    }
  }
}

Queries

`activitySets`

Response

Returns [ActivitySet!]!

Arguments

Name	Description
`limit` - `Int`	Limits the number of objects returned.
`offset` - `Int`	Start a the specified, zero-based array index. This is only useful in combination with `order_by`.
`order_by` - `[ActivitySetOrderByClause!]`	Sort the returned array by one or more fields of it's elements.
`where` - `ActivitySetWhereClause`	Filter the data by using a (nested) boolean expression.

Example

Query

query ActivitySets(
  $limit: Int,
  $offset: Int,
  $order_by: [ActivitySetOrderByClause!],
  $where: ActivitySetWhereClause
) {
  activitySets(
    limit: $limit,
    offset: $offset,
    order_by: $order_by,
    where: $where
  ) {
    activities {
      ...ActivityFragment
    }
    activitySetRef
    machine {
      ...MachineTPFragment
    }
    operation {
      ...OperationFragment
    }
    workOrderId
  }
}

Variables

{
  "limit": 987,
  "offset": 987,
  "order_by": [ActivitySetOrderByClause],
  "where": ActivitySetWhereClause
}

Response

{
  "data": {
    "activitySets": [
      {
        "activities": [Activity],
        "activitySetRef": 982312,
        "machine": MachineTP,
        "operation": Operation,
        "workOrderId": "abc123"
      }
    ]
  }
}

Queries

`activityType`

Response

Returns an ActivityType

Arguments

Name	Description
`activityTypeRef` - `bigint!`	A unique, numeric identifier for the activityType.

Example

Query

query ActivityType($activityTypeRef: bigint!) {
  activityType(activityTypeRef: $activityTypeRef) {
    activityMode
    activityTypeRef
    company {
      ...CompanyTPFragment
    }
    name
  }
}

Variables

{"activityTypeRef": 982312}

Response

{
  "data": {
    "activityType": {
      "activityMode": "production",
      "activityTypeRef": 982312,
      "company": {"name": "Cyberdynes"},
      "name": "xyz789"
    }
  }
}

Queries

`activityTypes`

Response

Returns [ActivityType!]!

Arguments

Name	Description
`limit` - `Int`	Limits the number of objects returned.
`offset` - `Int`	Start a the specified, zero-based array index. This is only useful in combination with `order_by`.
`order_by` - `[ActivityTypeOrderByClause!]`	Sort the returned array by one or more fields of it's elements.
`where` - `ActivityTypeWhereClause`	Filter the data by using a (nested) boolean expression.

Example

Query

query ActivityTypes(
  $limit: Int,
  $offset: Int,
  $order_by: [ActivityTypeOrderByClause!],
  $where: ActivityTypeWhereClause
) {
  activityTypes(
    limit: $limit,
    offset: $offset,
    order_by: $order_by,
    where: $where
  ) {
    activityMode
    activityTypeRef
    company {
      ...CompanyTPFragment
    }
    name
  }
}

Variables

{
  "limit": 987,
  "offset": 987,
  "order_by": [ActivityTypeOrderByClause],
  "where": ActivityTypeWhereClause
}

Response

{
  "data": {
    "activityTypes": [
      {
        "activityMode": "production",
        "activityTypeRef": 982312,
        "company": {"name": "Cyberdynes"},
        "name": "xyz789"
      }
    ]
  }
}

Queries

`aggregatedPartCounts`

Response

Returns [AggregatedPartCountRT!]!

Arguments

Name	Description
`args` - `aggregatedPartCountsArgs!`	A set of arguments passed to the function.
`distinct_on` - `[AggregatedPartCountRTField!]`	Return a distinct set of entities, defined by the given fields.
`limit` - `Int`	Limits the number of objects returned.
`offset` - `Int`	Start a the specified, zero-based array index. This is only useful in combination with `order_by`.
`order_by` - `[AggregatedPartCountRTOrderByClause!]`	Sort the returned array by one or more fields of it's elements.
`where` - `AggregatedPartCountRTWhereClause`	Filter the data by using a (nested) boolean expression.

Example

Query

query AggregatedPartCounts(
  $args: aggregatedPartCountsArgs!,
  $distinct_on: [AggregatedPartCountRTField!],
  $limit: Int,
  $offset: Int,
  $order_by: [AggregatedPartCountRTOrderByClause!],
  $where: AggregatedPartCountRTWhereClause
) {
  aggregatedPartCounts(
    args: $args,
    distinct_on: $distinct_on,
    limit: $limit,
    offset: $offset,
    order_by: $order_by,
    where: $where
  ) {
    avgValue
    bucketEndAt
    bucketStartAt
    bucketWidth
    eventCount
    firstBucketEventTime
    firstValue
    lastBucketEventTime
    lastValue
    machine {
      ...MachineTPFragment
    }
    machineRef
    maxValue
    metricKey
    minValue
    sumOfValues
  }
}

Variables

{
  "args": aggregatedPartCountsArgs,
  "distinct_on": ["avgValue"],
  "limit": 987,
  "offset": 123,
  "order_by": [AggregatedPartCountRTOrderByClause],
  "where": AggregatedPartCountRTWhereClause
}

Response

{
  "data": {
    "aggregatedPartCounts": [
      {
        "avgValue": 43.12,
        "bucketEndAt": "2022-05-07T01:08:03.420Z",
        "bucketStartAt": "2022-05-07T01:08:03.420Z",
        "bucketWidth": "1h",
        "eventCount": 987,
        "firstBucketEventTime": "2022-05-07T01:08:03.420Z",
        "firstValue": 987,
        "lastBucketEventTime": "2022-05-07T01:08:03.420Z",
        "lastValue": 123,
        "machine": MachineTP,
        "machineRef": 987,
        "maxValue": 987,
        "metricKey": "xyz789",
        "minValue": 123,
        "sumOfValues": 987
      }
    ]
  }
}

Queries

`aggregatedQuantities`

Response

Returns [AggregatedQuantityRT!]!

Arguments

Name	Description
`args` - `aggregatedQuantitiesArgs!`	A set of arguments passed to the function.
`limit` - `Int`	Limits the number of objects returned.
`offset` - `Int`	Start a the specified, zero-based array index. This is only useful in combination with `order_by`.
`order_by` - `[AggregatedQuantityRTOrderByClause!]`	Sort the returned array by one or more fields of it's elements.
`where` - `AggregatedQuantityRTWhereClause`	Filter the data by using a (nested) boolean expression.

Example

Query

query AggregatedQuantities(
  $args: aggregatedQuantitiesArgs!,
  $limit: Int,
  $offset: Int,
  $order_by: [AggregatedQuantityRTOrderByClause!],
  $where: AggregatedQuantityRTWhereClause
) {
  aggregatedQuantities(
    args: $args,
    limit: $limit,
    offset: $offset,
    order_by: $order_by,
    where: $where
  ) {
    avgValue
    bucketEndAt
    bucketStartAt
    bucketWidth
    eventCount
    firstBucketEventTime
    firstValue
    lastBucketEventTime
    lastValue
    machine {
      ...MachineTPFragment
    }
    machineRef
    maxValue
    metricKey
    minValue
    sumOfValues
  }
}

Variables

{
  "args": aggregatedQuantitiesArgs,
  "limit": 123,
  "offset": 987,
  "order_by": [AggregatedQuantityRTOrderByClause],
  "where": AggregatedQuantityRTWhereClause
}

Response

{
  "data": {
    "aggregatedQuantities": [
      {
        "avgValue": 43.12,
        "bucketEndAt": "2022-05-07T01:08:03.420Z",
        "bucketStartAt": "2022-05-07T01:08:03.420Z",
        "bucketWidth": "1h",
        "eventCount": 987,
        "firstBucketEventTime": "2022-05-07T01:08:03.420Z",
        "firstValue": 43.12,
        "lastBucketEventTime": "2022-05-07T01:08:03.420Z",
        "lastValue": 43.12,
        "machine": MachineTP,
        "machineRef": 123,
        "maxValue": 43.12,
        "metricKey": "xyz789",
        "minValue": 43.12,
        "sumOfValues": 43.12
      }
    ]
  }
}

Queries

`alarmIntervals`

Response

Returns [AlarmIntervalRT!]!

Arguments

Name	Description
`args` - `alarmIntervalsArgs!`	A set of arguments passed to the function.
`distinct_on` - `[AlarmIntervalRTField!]`	Return a distinct set of entities, defined by the given fields.
`limit` - `Int`	Limits the number of objects returned.
`offset` - `Int`	Start a the specified, zero-based array index. This is only useful in combination with `order_by`.
`order_by` - `[AlarmIntervalRTOrderByClause!]`	Sort the returned array by one or more fields of it's elements.
`where` - `AlarmIntervalRTWhereClause`	Filter the data by using a (nested) boolean expression.

Example

Query

query AlarmIntervals(
  $args: alarmIntervalsArgs!,
  $distinct_on: [AlarmIntervalRTField!],
  $limit: Int,
  $offset: Int,
  $order_by: [AlarmIntervalRTOrderByClause!],
  $where: AlarmIntervalRTWhereClause
) {
  alarmIntervals(
    args: $args,
    distinct_on: $distinct_on,
    limit: $limit,
    offset: $offset,
    order_by: $order_by,
    where: $where
  ) {
    description
    endAt
    label
    machine {
      ...MachineTPFragment
    }
    machineRef
    metricKey
    nativeCode
    sequence
    startAt
  }
}

Variables

{
  "args": alarmIntervalsArgs,
  "distinct_on": ["description"],
  "limit": 987,
  "offset": 123,
  "order_by": [AlarmIntervalRTOrderByClause],
  "where": AlarmIntervalRTWhereClause
}

Response

{
  "data": {
    "alarmIntervals": [
      {
        "description": "xyz789",
        "endAt": "2022-05-07T01:08:03.420Z",
        "label": "abc123",
        "machine": MachineTP,
        "machineRef": 987,
        "metricKey": "xyz789",
        "nativeCode": "abc123",
        "sequence": 123,
        "startAt": "2022-05-07T01:08:03.420Z"
      }
    ]
  }
}

Queries

`annotationTypes`

Response

Returns [AnnotationTypeTP!]!

Arguments

Name	Description
`limit` - `Int`	Limits the number of objects returned.
`offset` - `Int`	Start a the specified, zero-based array index. This is only useful in combination with `order_by`.
`order_by` - `[AnnotationTypeTPOrderByClause!]`	Sort the returned array by one or more fields of it's elements.
`where` - `AnnotationTypeTPWhereClause`	Filter the data by using a (nested) boolean expression.

Example

Query

query AnnotationTypes(
  $limit: Int,
  $offset: Int,
  $order_by: [AnnotationTypeTPOrderByClause!],
  $where: AnnotationTypeTPWhereClause
) {
  annotationTypes(
    limit: $limit,
    offset: $offset,
    order_by: $order_by,
    where: $where
  ) {
    annotationTypeRef
    annotations {
      ...AnnotationTPFragment
    }
    color
    company {
      ...CompanyTPFragment
    }
    isArchived
    name
  }
}

Variables

{
  "limit": 987,
  "offset": 987,
  "order_by": [AnnotationTypeTPOrderByClause],
  "where": AnnotationTypeTPWhereClause
}

Response

{
  "data": {
    "annotationTypes": [
      {
        "annotationTypeRef": 987,
        "annotations": [AnnotationTP],
        "color": "xyz789",
        "company": {"name": "Cyberdynes"},
        "isArchived": false,
        "name": "xyz789"
      }
    ]
  }
}

Queries

`annotations`

Response

Returns [AnnotationTP!]!

Arguments

Name	Description
`limit` - `Int`	Limits the number of objects returned.
`offset` - `Int`	Start a the specified, zero-based array index. This is only useful in combination with `order_by`.
`order_by` - `[AnnotationTPOrderByClause!]`	Sort the returned array by one or more fields of it's elements.
`where` - `AnnotationTPWhereClause`	Filter the data by using a (nested) boolean expression.

Example

Query

query Annotations(
  $limit: Int,
  $offset: Int,
  $order_by: [AnnotationTPOrderByClause!],
  $where: AnnotationTPWhereClause
) {
  annotations(
    limit: $limit,
    offset: $offset,
    order_by: $order_by,
    where: $where
  ) {
    annotationRef
    annotationType {
      ...AnnotationTypeTPFragment
    }
    companyId
    description
    endAt
    isPlanned
    machine {
      ...MachineTPFragment
    }
    machineRef
    startAt
  }
}

Variables

{
  "limit": 123,
  "offset": 123,
  "order_by": [AnnotationTPOrderByClause],
  "where": AnnotationTPWhereClause
}

Response

{
  "data": {
    "annotations": [
      {
        "annotationRef": 123,
        "annotationType": AnnotationTypeTP,
        "companyId": "abc123",
        "description": "abc123",
        "endAt": "2022-05-07T01:08:03.420Z",
        "isPlanned": false,
        "machine": MachineTP,
        "machineRef": 987,
        "startAt": "2022-05-07T01:08:03.420Z"
      }
    ]
  }
}

Queries

`companies`

Description

Fetch all companies accessible by the role.

Response

Returns [CompanyTP!]!

Arguments

Name	Description
`limit` - `Int`	Limits the number of objects returned.
`offset` - `Int`	Start a the specified, zero-based array index. This is only useful in combination with `order_by`.
`order_by` - `[CompanyTPOrderByClause!]`	Sort the returned array by one or more fields of it's elements.
`where` - `CompanyTPWhereClause`	Filter the data by using a (nested) boolean expression.

Example

Query

query Companies(
  $limit: Int,
  $offset: Int,
  $order_by: [CompanyTPOrderByClause!],
  $where: CompanyTPWhereClause
) {
  companies(
    limit: $limit,
    offset: $offset,
    order_by: $order_by,
    where: $where
  ) {
    activityTypes {
      ...ActivityTypeFragment
    }
    addressText
    annotationTypes {
      ...AnnotationTypeTPFragment
    }
    companyId
    machines {
      ...MachineTPFragment
    }
    name
    operations {
      ...OperationFragment
    }
    operators {
      ...OperatorTPFragment
    }
    rejectReasons {
      ...RejectReasonFragment
    }
    timeZone
  }
}

Variables

{
  "limit": 987,
  "offset": 123,
  "order_by": [CompanyTPOrderByClause],
  "where": CompanyTPWhereClause
}

Response

{
  "data": {
    "companies": [
      {
        "activityTypes": [ActivityType],
        "addressText": "120 Podmayer Lane, Amherst, MA 01002",
        "annotationTypes": [AnnotationTypeTP],
        "companyId": "xyz789",
        "machines": [MachineTP],
        "name": "abc123",
        "operations": [Operation],
        "operators": [OperatorTP],
        "rejectReasons": [RejectReason],
        "timeZone": "abc123"
      }
    ]
  }
}

Queries

`currentAlarmsByMachine`

Response

Returns [CurrentAlarmRT!]!

Arguments

Name	Description
`args` - `currentAlarmsByMachineArgs!`	A set of arguments passed to the function.
`distinct_on` - `[CurrentAlarmRTField!]`	Return a distinct set of entities, defined by the given fields.
`limit` - `Int`	Limits the number of objects returned.
`offset` - `Int`	Start a the specified, zero-based array index. This is only useful in combination with `order_by`.
`order_by` - `[CurrentAlarmRTOrderByClause!]`	Sort the returned array by one or more fields of it's elements.
`where` - `CurrentAlarmRTWhereClause`	Filter the data by using a (nested) boolean expression.

Example

Query

query CurrentAlarmsByMachine(
  $args: currentAlarmsByMachineArgs!,
  $distinct_on: [CurrentAlarmRTField!],
  $limit: Int,
  $offset: Int,
  $order_by: [CurrentAlarmRTOrderByClause!],
  $where: CurrentAlarmRTWhereClause
) {
  currentAlarmsByMachine(
    args: $args,
    distinct_on: $distinct_on,
    limit: $limit,
    offset: $offset,
    order_by: $order_by,
    where: $where
  ) {
    description
    label
    latestEventAt
    machine {
      ...MachineTPFragment
    }
    machineRef
    metricKey
    nativeCode
    startAt
  }
}

Variables

{
  "args": currentAlarmsByMachineArgs,
  "distinct_on": ["description"],
  "limit": 123,
  "offset": 987,
  "order_by": [CurrentAlarmRTOrderByClause],
  "where": CurrentAlarmRTWhereClause
}

Response

{
  "data": {
    "currentAlarmsByMachine": [
      {
        "description": "abc123",
        "label": "xyz789",
        "latestEventAt": "2022-05-07T01:08:03.420Z",
        "machine": MachineTP,
        "machineRef": 987,
        "metricKey": "xyz789",
        "nativeCode": "xyz789",
        "startAt": "2022-05-07T01:08:03.420Z"
      }
    ]
  }
}

Queries

`currentStatesByMachine`

Response

Returns [CurrentStateRT!]!

Arguments

Name	Description
`args` - `currentStatesByMachineArgs!`	A set of arguments passed to the function.
`distinct_on` - `[CurrentStateRTField!]`	Return a distinct set of entities, defined by the given fields.
`limit` - `Int`	Limits the number of objects returned.
`offset` - `Int`	Start a the specified, zero-based array index. This is only useful in combination with `order_by`.
`order_by` - `[CurrentStateRTOrderByClause!]`	Sort the returned array by one or more fields of it's elements.
`where` - `CurrentStateRTWhereClause`	Filter the data by using a (nested) boolean expression.

Example

Query

query CurrentStatesByMachine(
  $args: currentStatesByMachineArgs!,
  $distinct_on: [CurrentStateRTField!],
  $limit: Int,
  $offset: Int,
  $order_by: [CurrentStateRTOrderByClause!],
  $where: CurrentStateRTWhereClause
) {
  currentStatesByMachine(
    args: $args,
    distinct_on: $distinct_on,
    limit: $limit,
    offset: $offset,
    order_by: $order_by,
    where: $where
  ) {
    latestEventAt
    machine {
      ...MachineTPFragment
    }
    machineRef
    metricKey
    startAt
    value
  }
}

Variables

{
  "args": currentStatesByMachineArgs,
  "distinct_on": ["latestEventAt"],
  "limit": 987,
  "offset": 123,
  "order_by": [CurrentStateRTOrderByClause],
  "where": CurrentStateRTWhereClause
}

Response

{
  "data": {
    "currentStatesByMachine": [
      {
        "latestEventAt": "2022-05-07T01:08:03.420Z",
        "machine": MachineTP,
        "machineRef": 987,
        "metricKey": "abc123",
        "startAt": "2022-05-07T01:08:03.420Z",
        "value": "abc123"
      }
    ]
  }
}

Queries

`latestPositionsByMachine`

Response

Returns [LatestPositionRT!]!

Arguments

Name	Description
`args` - `latestPositionsByMachineArgs!`	A set of arguments passed to the function.
`distinct_on` - `[LatestPositionRTField!]`	Return a distinct set of entities, defined by the given fields.
`limit` - `Int`	Limits the number of objects returned.
`offset` - `Int`	Start a the specified, zero-based array index. This is only useful in combination with `order_by`.
`order_by` - `[LatestPositionRTOrderByClause!]`	Sort the returned array by one or more fields of it's elements.
`where` - `LatestPositionRTWhereClause`	Filter the data by using a (nested) boolean expression.

Example

Query

query LatestPositionsByMachine(
  $args: latestPositionsByMachineArgs!,
  $distinct_on: [LatestPositionRTField!],
  $limit: Int,
  $offset: Int,
  $order_by: [LatestPositionRTOrderByClause!],
  $where: LatestPositionRTWhereClause
) {
  latestPositionsByMachine(
    args: $args,
    distinct_on: $distinct_on,
    limit: $limit,
    offset: $offset,
    order_by: $order_by,
    where: $where
  ) {
    eventTime
    machine {
      ...MachineTPFragment
    }
    machineRef
    metricKey
    x
    y
    z
  }
}

Variables

{
  "args": latestPositionsByMachineArgs,
  "distinct_on": ["eventTime"],
  "limit": 123,
  "offset": 987,
  "order_by": [LatestPositionRTOrderByClause],
  "where": LatestPositionRTWhereClause
}

Response

{
  "data": {
    "latestPositionsByMachine": [
      {
        "eventTime": "2022-05-07T01:08:03.420Z",
        "machine": MachineTP,
        "machineRef": 123,
        "metricKey": "xyz789",
        "x": 43.12,
        "y": 43.12,
        "z": 43.12
      }
    ]
  }
}

Queries

`latestQuantitiesByMachine`

Response

Returns [LatestQuantityRT!]!

Arguments

Name	Description
`args` - `latestQuantitiesByMachineArgs!`	A set of arguments passed to the function.
`distinct_on` - `[LatestQuantityRTField!]`	Return a distinct set of entities, defined by the given fields.
`limit` - `Int`	Limits the number of objects returned.
`offset` - `Int`	Start a the specified, zero-based array index. This is only useful in combination with `order_by`.
`where` - `LatestQuantityRTWhereClause`	Filter the data by using a (nested) boolean expression.

Example

Query

query LatestQuantitiesByMachine(
  $args: latestQuantitiesByMachineArgs!,
  $distinct_on: [LatestQuantityRTField!],
  $limit: Int,
  $offset: Int,
  $where: LatestQuantityRTWhereClause
) {
  latestQuantitiesByMachine(
    args: $args,
    distinct_on: $distinct_on,
    limit: $limit,
    offset: $offset,
    where: $where
  ) {
    eventTime
    machine {
      ...MachineTPFragment
    }
    machineRef
    metricKey
    sequence
    value
  }
}

Variables

{
  "args": latestQuantitiesByMachineArgs,
  "distinct_on": ["eventTime"],
  "limit": 987,
  "offset": 987,
  "where": LatestQuantityRTWhereClause
}

Response

{
  "data": {
    "latestQuantitiesByMachine": [
      {
        "eventTime": "2022-05-07T01:08:03.420Z",
        "machine": MachineTP,
        "machineRef": 123,
        "metricKey": "xyz789",
        "sequence": 987,
        "value": 43.12
      }
    ]
  }
}

Queries

`machines`

Response

Returns [MachineTP!]!

Arguments

Name	Description
`limit` - `Int`	Limits the number of objects returned.
`offset` - `Int`	Start a the specified, zero-based array index. This is only useful in combination with `order_by`.
`order_by` - `[MachineTPOrderByClause!]`	Sort the returned array by one or more fields of it's elements.
`where` - `MachineTPWhereClause`	Filter the data by using a (nested) boolean expression.

Example

Query

query Machines(
  $limit: Int,
  $offset: Int,
  $order_by: [MachineTPOrderByClause!],
  $where: MachineTPWhereClause
) {
  machines(
    limit: $limit,
    offset: $offset,
    order_by: $order_by,
    where: $where
  ) {
    activitySets {
      ...ActivitySetFragment
    }
    annotations {
      ...AnnotationTPFragment
    }
    company {
      ...CompanyTPFragment
    }
    currentAlarms {
      ...CurrentAlarmRTFragment
    }
    currentStates {
      ...CurrentStateRTFragment
    }
    decommissionedAt
    latestPositions {
      ...LatestPositionRTFragment
    }
    latestQuantities {
      ...LatestQuantityRTFragment
    }
    machineRef
    make
    metrics {
      ...MetricRTFragment
    }
    model
    name
    operatorRuns {
      ...OperatorRunTPFragment
    }
    partCountCorrections {
      ...PartCountCorrectionFragment
    }
    rejects {
      ...RejectFragment
    }
  }
}

Variables

{
  "limit": 123,
  "offset": 987,
  "order_by": [MachineTPOrderByClause],
  "where": MachineTPWhereClause
}

Response

{
  "data": {
    "machines": [
      {
        "activitySets": [ActivitySet],
        "annotations": [AnnotationTP],
        "company": {
          "companyId": "01c08a38-f33d-4348-9918-e6957cab5c27",
          "name": "Cyberdyne"
        },
        "currentAlarms": [CurrentAlarmRT],
        "currentStates": [CurrentStateRT],
        "decommissionedAt": "2022-05-07T01:08:03.420Z",
        "latestPositions": [LatestPositionRT],
        "latestQuantities": [LatestQuantityRT],
        "machineRef": 987,
        "make": "Citizen",
        "metrics": [MetricRT],
        "model": "K16E",
        "name": "Citizen B12",
        "operatorRuns": [OperatorRunTP],
        "partCountCorrections": [PartCountCorrection],
        "rejects": [Reject]
      }
    ]
  }
}

Queries

`metrics`

Response

Returns [MetricRT!]!

Arguments

Name	Description
`limit` - `Int`	Limits the number of objects returned.
`offset` - `Int`	Start a the specified, zero-based array index. This is only useful in combination with `order_by`.
`order_by` - `[MetricRTOrderByClause!]`	Sort the returned array by one or more fields of it's elements.
`where` - `MetricRTWhereClause`	Filter the data by using a (nested) boolean expression.

Example

Query

query Metrics(
  $limit: Int,
  $offset: Int,
  $order_by: [MetricRTOrderByClause!],
  $where: MetricRTWhereClause
) {
  metrics(
    limit: $limit,
    offset: $offset,
    order_by: $order_by,
    where: $where
  ) {
    machine {
      ...MachineTPFragment
    }
    machineRef
    metricKey
    subtype
    type
  }
}

Variables

{
  "limit": 123,
  "offset": 123,
  "order_by": [MetricRTOrderByClause],
  "where": MetricRTWhereClause
}

Response

{
  "data": {
    "metrics": [
      {
        "machine": MachineTP,
        "machineRef": 987,
        "metricKey": "xyz789",
        "subtype": "xyz789",
        "type": "xyz789"
      }
    ]
  }
}

Queries

`operations`

Response

Returns [Operation!]!

Arguments

Name	Description
`limit` - `Int`	Limits the number of objects returned.
`offset` - `Int`	Start a the specified, zero-based array index. This is only useful in combination with `order_by`.
`order_by` - `[OperationOrderByClause!]`	Sort the returned array by one or more fields of it's elements.
`where` - `OperationWhereClause`	Filter the data by using a (nested) boolean expression.

Example

Query

query Operations(
  $limit: Int,
  $offset: Int,
  $order_by: [OperationOrderByClause!],
  $where: OperationWhereClause
) {
  operations(
    limit: $limit,
    offset: $offset,
    order_by: $order_by,
    where: $where
  ) {
    activitySets {
      ...ActivitySetFragment
    }
    company {
      ...CompanyTPFragment
    }
    name
    operationId
  }
}

Variables

{
  "limit": 123,
  "offset": 987,
  "order_by": [OperationOrderByClause],
  "where": OperationWhereClause
}

Response

{
  "data": {
    "operations": [
      {
        "activitySets": [ActivitySet],
        "company": {"name": "Cyberdynes"},
        "name": "abc123",
        "operationId": "abc123"
      }
    ]
  }
}

Queries

`operatorRuns`

Response

Returns [OperatorRunTP!]!

Arguments

Name	Description
`limit` - `Int`	Limits the number of objects returned.
`offset` - `Int`	Start a the specified, zero-based array index. This is only useful in combination with `order_by`.
`order_by` - `[OperatorRunTPOrderByClause!]`	Sort the returned array by one or more fields of it's elements.
`where` - `OperatorRunTPWhereClause`	Filter the data by using a (nested) boolean expression.

Example

Query

query OperatorRuns(
  $limit: Int,
  $offset: Int,
  $order_by: [OperatorRunTPOrderByClause!],
  $where: OperatorRunTPWhereClause
) {
  operatorRuns(
    limit: $limit,
    offset: $offset,
    order_by: $order_by,
    where: $where
  ) {
    endAt
    machine {
      ...MachineTPFragment
    }
    operator {
      ...OperatorTPFragment
    }
    operatorRunRef
    startAt
  }
}

Variables

{
  "limit": 987,
  "offset": 987,
  "order_by": [OperatorRunTPOrderByClause],
  "where": OperatorRunTPWhereClause
}

Response

{
  "data": {
    "operatorRuns": [
      {
        "endAt": "2022-05-07T01:08:03.420Z",
        "machine": MachineTP,
        "operator": OperatorTP,
        "operatorRunRef": 123,
        "startAt": "2022-05-07T01:08:03.420Z"
      }
    ]
  }
}

Queries

`operators`

Description

Returns a collection of Operators

Response

Returns [OperatorTP!]!

Arguments

Name	Description
`limit` - `Int`	Limits the number of objects returned.
`offset` - `Int`	Start a the specified, zero-based array index. This is only useful in combination with `order_by`.
`order_by` - `[OperatorTPOrderByClause!]`	Sort the returned array by one or more fields of it's elements.
`where` - `OperatorTPWhereClause`	Filter the data by using a (nested) boolean expression.

Example

Query

query Operators(
  $limit: Int,
  $offset: Int,
  $order_by: [OperatorTPOrderByClause!],
  $where: OperatorTPWhereClause
) {
  operators(
    limit: $limit,
    offset: $offset,
    order_by: $order_by,
    where: $where
  ) {
    company {
      ...CompanyTPFragment
    }
    isArchived
    name
    operatorRef
    operatorRuns {
      ...OperatorRunTPFragment
    }
  }
}

Variables

{
  "limit": 123,
  "offset": 123,
  "order_by": [OperatorTPOrderByClause],
  "where": OperatorTPWhereClause
}

Response

{
  "data": {
    "operators": [
      {
        "company": {"name": "Cyberdynes"},
        "isArchived": false,
        "name": "abc123",
        "operatorRef": 987,
        "operatorRuns": [OperatorRunTP]
      }
    ]
  }
}

Queries

`partCountCorrections`

Response

Returns [PartCountCorrection!]!

Arguments

Name	Description
`limit` - `Int`	Limits the number of objects returned.
`offset` - `Int`	Start a the specified, zero-based array index. This is only useful in combination with `order_by`.
`order_by` - `[PartCountCorrectionOrderByClause!]`	Sort the returned array by one or more fields of it's elements.
`where` - `PartCountCorrectionWhereClause`	Filter the data by using a (nested) boolean expression.

Example

Query

query PartCountCorrections(
  $limit: Int,
  $offset: Int,
  $order_by: [PartCountCorrectionOrderByClause!],
  $where: PartCountCorrectionWhereClause
) {
  partCountCorrections(
    limit: $limit,
    offset: $offset,
    order_by: $order_by,
    where: $where
  ) {
    effectiveAt
    machine {
      ...MachineTPFragment
    }
    value
  }
}

Variables

{
  "limit": 123,
  "offset": 123,
  "order_by": [PartCountCorrectionOrderByClause],
  "where": PartCountCorrectionWhereClause
}

Response

{
  "data": {
    "partCountCorrections": [
      {
        "effectiveAt": "2022-05-07T01:08:03.420Z",
        "machine": MachineTP,
        "value": 987
      }
    ]
  }
}

Queries

`partCounts`

Response

Returns [PartCountRT!]!

Arguments

Name	Description
`args` - `partCountsArgs!`	A set of arguments passed to the function.
`distinct_on` - `[PartCountRTField!]`	Return a distinct set of entities, defined by the given fields.
`limit` - `Int`	Limits the number of objects returned.
`offset` - `Int`	Start a the specified, zero-based array index. This is only useful in combination with `order_by`.
`order_by` - `[PartCountRTOrderByClause!]`	Sort the returned array by one or more fields of it's elements.
`where` - `PartCountRTWhereClause`	Filter the data by using a (nested) boolean expression.

Example

Query

query PartCounts(
  $args: partCountsArgs!,
  $distinct_on: [PartCountRTField!],
  $limit: Int,
  $offset: Int,
  $order_by: [PartCountRTOrderByClause!],
  $where: PartCountRTWhereClause
) {
  partCounts(
    args: $args,
    distinct_on: $distinct_on,
    limit: $limit,
    offset: $offset,
    order_by: $order_by,
    where: $where
  ) {
    eventTime
    machine {
      ...MachineTPFragment
    }
    machineRef
    metricKey
    sequence
    value
  }
}

Variables

{
  "args": partCountsArgs,
  "distinct_on": ["eventTime"],
  "limit": 987,
  "offset": 987,
  "order_by": [PartCountRTOrderByClause],
  "where": PartCountRTWhereClause
}

Response

{
  "data": {
    "partCounts": [
      {
        "eventTime": "2022-05-07T01:08:03.420Z",
        "machine": MachineTP,
        "machineRef": 123,
        "metricKey": "abc123",
        "sequence": 123,
        "value": 123
      }
    ]
  }
}

Queries

`positions`

Response

Returns [PositionRT!]!

Arguments

Name	Description
`args` - `positionsArgs!`	A set of arguments passed to the function.
`distinct_on` - `[PositionRTField!]`	Return a distinct set of entities, defined by the given fields.
`limit` - `Int`	Limits the number of objects returned.
`offset` - `Int`	Start a the specified, zero-based array index. This is only useful in combination with `order_by`.
`order_by` - `[PositionRTOrderByClause!]`	Sort the returned array by one or more fields of it's elements.
`where` - `PositionRTWhereClause`	Filter the data by using a (nested) boolean expression.

Example

Query

query Positions(
  $args: positionsArgs!,
  $distinct_on: [PositionRTField!],
  $limit: Int,
  $offset: Int,
  $order_by: [PositionRTOrderByClause!],
  $where: PositionRTWhereClause
) {
  positions(
    args: $args,
    distinct_on: $distinct_on,
    limit: $limit,
    offset: $offset,
    order_by: $order_by,
    where: $where
  ) {
    eventTime
    machine {
      ...MachineTPFragment
    }
    machineRef
    metricKey
    x
    y
    z
  }
}

Variables

{
  "args": positionsArgs,
  "distinct_on": ["eventTime"],
  "limit": 987,
  "offset": 987,
  "order_by": [PositionRTOrderByClause],
  "where": PositionRTWhereClause
}

Response

{
  "data": {
    "positions": [
      {
        "eventTime": "2022-05-07T01:08:03.420Z",
        "machine": MachineTP,
        "machineRef": 123,
        "metricKey": "abc123",
        "x": 43.12,
        "y": 43.12,
        "z": 43.12
      }
    ]
  }
}

Queries

`quantities`

Response

Returns [QuantityRT!]!

Arguments

Name	Description
`args` - `quantitiesArgs!`	A set of arguments passed to the function.
`distinct_on` - `[QuantityRTField!]`	Return a distinct set of entities, defined by the given fields.
`limit` - `Int`	Limits the number of objects returned.
`offset` - `Int`	Start a the specified, zero-based array index. This is only useful in combination with `order_by`.
`order_by` - `[QuantityRTOrderByClause!]`	Sort the returned array by one or more fields of it's elements.
`where` - `QuantityRTWhereClause`	Filter the data by using a (nested) boolean expression.

Example

Query

query Quantities(
  $args: quantitiesArgs!,
  $distinct_on: [QuantityRTField!],
  $limit: Int,
  $offset: Int,
  $order_by: [QuantityRTOrderByClause!],
  $where: QuantityRTWhereClause
) {
  quantities(
    args: $args,
    distinct_on: $distinct_on,
    limit: $limit,
    offset: $offset,
    order_by: $order_by,
    where: $where
  ) {
    eventTime
    machine {
      ...MachineTPFragment
    }
    machineRef
    metricKey
    sequence
    value
  }
}

Variables

{
  "args": quantitiesArgs,
  "distinct_on": ["eventTime"],
  "limit": 987,
  "offset": 987,
  "order_by": [QuantityRTOrderByClause],
  "where": QuantityRTWhereClause
}

Response

{
  "data": {
    "quantities": [
      {
        "eventTime": "2022-05-07T01:08:03.420Z",
        "machine": MachineTP,
        "machineRef": 123,
        "metricKey": "xyz789",
        "sequence": 987,
        "value": 43.12
      }
    ]
  }
}

Queries

`rejectReasons`

Response

Returns [RejectReason!]!

Arguments

Name	Description
`limit` - `Int`	Limits the number of objects returned.
`offset` - `Int`	Start a the specified, zero-based array index. This is only useful in combination with `order_by`.
`order_by` - `[RejectReasonOrderByClause!]`	Sort the returned array by one or more fields of it's elements.
`where` - `RejectReasonWhereClause`	Filter the data by using a (nested) boolean expression.

Example

Query

query RejectReasons(
  $limit: Int,
  $offset: Int,
  $order_by: [RejectReasonOrderByClause!],
  $where: RejectReasonWhereClause
) {
  rejectReasons(
    limit: $limit,
    offset: $offset,
    order_by: $order_by,
    where: $where
  ) {
    color
    company {
      ...CompanyTPFragment
    }
    isArchived
    name
    rejectReasonRef
    rejects {
      ...RejectFragment
    }
  }
}

Variables

{
  "limit": 987,
  "offset": 123,
  "order_by": [RejectReasonOrderByClause],
  "where": RejectReasonWhereClause
}

Response

{
  "data": {
    "rejectReasons": [
      {
        "color": "abc123",
        "company": {"name": "Cyberdynes"},
        "isArchived": true,
        "name": "xyz789",
        "rejectReasonRef": 123,
        "rejects": [Reject]
      }
    ]
  }
}

Queries

`rejects`

Response

Returns [Reject!]!

Arguments

Name	Description
`limit` - `Int`	Limits the number of objects returned.
`offset` - `Int`	Start a the specified, zero-based array index. This is only useful in combination with `order_by`.
`order_by` - `[RejectOrderByClause!]`	Sort the returned array by one or more fields of it's elements.
`where` - `RejectWhereClause`	Filter the data by using a (nested) boolean expression.

Example

Query

query Rejects(
  $limit: Int,
  $offset: Int,
  $order_by: [RejectOrderByClause!],
  $where: RejectWhereClause
) {
  rejects(
    limit: $limit,
    offset: $offset,
    order_by: $order_by,
    where: $where
  ) {
    machine {
      ...MachineTPFragment
    }
    rejectId
    rejectReason {
      ...RejectReasonFragment
    }
    rejectType
    rejectedAt
    value
  }
}

Variables

{
  "limit": 123,
  "offset": 987,
  "order_by": [RejectOrderByClause],
  "where": RejectWhereClause
}

Response

{
  "data": {
    "rejects": [
      {
        "machine": MachineTP,
        "rejectId": "abc123",
        "rejectReason": RejectReason,
        "rejectType": "xyz789",
        "rejectedAt": "2022-05-07T01:08:03.420Z",
        "value": 987
      }
    ]
  }
}

Queries

`stateIntervals`

Response

Returns [StateIntervalRT!]!

Arguments

Name	Description
`args` - `stateIntervalsArgs!`	A set of arguments passed to the function.
`distinct_on` - `[StateIntervalRTField!]`	Return a distinct set of entities, defined by the given fields.
`limit` - `Int`	Limits the number of objects returned.
`offset` - `Int`	Start a the specified, zero-based array index. This is only useful in combination with `order_by`.
`order_by` - `[StateIntervalRTOrderByClause!]`	Sort the returned array by one or more fields of it's elements.
`where` - `StateIntervalRTWhereClause`	Filter the data by using a (nested) boolean expression.

Example

Query

query StateIntervals(
  $args: stateIntervalsArgs!,
  $distinct_on: [StateIntervalRTField!],
  $limit: Int,
  $offset: Int,
  $order_by: [StateIntervalRTOrderByClause!],
  $where: StateIntervalRTWhereClause
) {
  stateIntervals(
    args: $args,
    distinct_on: $distinct_on,
    limit: $limit,
    offset: $offset,
    order_by: $order_by,
    where: $where
  ) {
    endAt
    machine {
      ...MachineTPFragment
    }
    machineRef
    metric {
      ...MetricRTFragment
    }
    metricKey
    startAt
    value
  }
}

Variables

{
  "args": stateIntervalsArgs,
  "distinct_on": ["endAt"],
  "limit": 987,
  "offset": 987,
  "order_by": [StateIntervalRTOrderByClause],
  "where": StateIntervalRTWhereClause
}

Response

{
  "data": {
    "stateIntervals": [
      {
        "endAt": "2022-05-07T01:08:03.420Z",
        "machine": MachineTP,
        "machineRef": 987,
        "metric": MetricRT,
        "metricKey": "xyz789",
        "startAt": "2022-05-07T01:08:03.420Z",
        "value": "abc123"
      }
    ]
  }
}

Types

Activity

Description

Activities are discrete periods of time that specific work is performed on a piece of equipment. They connect a start and end time to specific goals for a machine: the part being produced (optionally including workorder information and other data points) as well as the production and setup standards.

Fields

Field Name	Description
`activityRef` - `bigint`	A unique, numeric identifier for the activity.
`activitySet` - `ActivitySet`
`activityType` - `ActivityType`
`endAt` - `timestamptz`	The end of an interval. Intervals are right-exclusive.
`startAt` - `timestamptz`	The start of an interval.

Example

{
  "activityRef": 982312,
  "activitySet": ActivitySet,
  "activityType": ActivityType,
  "endAt": "2022-05-07T01:08:03.420Z",
  "startAt": "2022-05-07T01:08:03.420Z"
}

Types

ActivityField

Values

Enum Value	Description
`activityRef`	A unique, numeric identifier for the activity.
`endAt`	The end of an interval. Intervals are right-exclusive.
`startAt`	The start of an interval.

Example

"activityRef"

Types

ActivityOrderByClause

Fields

Input Field	Description
`activityRef` - `order_by`	A unique, numeric identifier for the activity.
`activitySet` - `ActivitySetOrderByClause`
`activityType` - `ActivityTypeOrderByClause`
`endAt` - `order_by`	The end of an interval. Intervals are right-exclusive.
`startAt` - `order_by`	The start of an interval.

Example

{
  "activityRef": "asc",
  "activitySet": ActivitySetOrderByClause,
  "activityType": ActivityTypeOrderByClause,
  "endAt": "asc",
  "startAt": "asc"
}

Types

ActivitySet

Description

Each Activity is a distinct span of time, but they can be rolled up into a complete effort using Activity Sets. Activity Sets allow for work to be paused and resumed on a piece of equipment, or a transition from setup to production, while maintaining each Activity as step toward a greater goal. An Activity Set is the data model backing a Production Run.

Fields

Field Name	Description
`activities` - `[Activity!]!`
Arguments `distinct_on` - `[ActivityField!]` Return a distinct set of entities, defined by the given fields. `limit` - `Int` Limits the number of objects returned. `offset` - `Int` Start a the specified, zero-based array index. This is only useful in combination with `order_by`. `order_by` - `[ActivityOrderByClause!]` Sort the returned array by one or more fields of it's elements. `where` - `ActivityWhereClause` Filter the data by using a (nested) boolean expression.
`activitySetRef` - `bigint!`	A unique, numeric identifier for the activitySet.
`machine` - `MachineTP`	The machine the event originates from.
`operation` - `Operation`
`workOrderId` - `String`	An identifier for the work order. The identifier is usually generated in a third party system (ERP).

Example

{
  "activities": [Activity],
  "activitySetRef": 982312,
  "machine": MachineTP,
  "operation": Operation,
  "workOrderId": "xyz789"
}

Types

ActivitySetField

Values

Enum Value	Description
`activitySetRef`	A unique, numeric identifier for the activitySet.
`workOrderId`	A globally unique identifier (UUID) for the workOrder.

Example

"activitySetRef"

Types

ActivitySetOrderByClause

Fields

Input Field	Description
`activitySetRef` - `order_by`	A unique, numeric identifier for the activitySet.
`machine` - `MachineTPOrderByClause`	The machine the event originates from.
`operation` - `OperationOrderByClause`
`workOrderId` - `order_by`	A globally unique identifier (UUID) for the workOrder.

Example

{
  "activitySetRef": "asc",
  "machine": MachineTPOrderByClause,
  "operation": OperationOrderByClause,
  "workOrderId": "asc"
}

Types

ActivitySetWhereClause

Fields

Input Field	Description
`_and` - `[ActivitySetWhereClause!]`	Combines the given expressions using a logical AND
`_not` - `ActivitySetWhereClause`	Negates the result of the given expression.
`_or` - `[ActivitySetWhereClause!]`	Combines the given expressions using a logical OR.
`activities` - `ActivityWhereClause`
`activitySetRef` - `bigintComparison`	A unique, numeric identifier for the activitySet.
`machine` - `MachineTPWhereClause`	The machine the event originates from.
`operation` - `OperationWhereClause`
`workOrderId` - `StringComparison`	A globally unique identifier (UUID) for the workOrder.

Example

{
  "_and": [ActivitySetWhereClause],
  "_not": ActivitySetWhereClause,
  "_or": [ActivitySetWhereClause],
  "activities": ActivityWhereClause,
  "activitySetRef": bigintComparison,
  "machine": MachineTPWhereClause,
  "operation": OperationWhereClause,
  "workOrderId": StringComparison
}

Types

ActivityType

Description

Throughout the lifespan of an Activity Set, multiple types of Activities can be performed. Activity Types are broken down into distinct modes that are uniquely supported by MachineMetrics and result in differing behavior within the user experience. The two modes that are supported by MachineMetrics at launch are Setup and Production. Activity Types allow for these modes to be broken down into differently labeled types. For example, the setup mode can be broken down into customer definable stages like Teardown, Tooling, and First Piece Inspection. Combined with Workflows, Activities can be used to notify key stakeholders in a process to take action when certain activities are started or work is projected to fail in achieving a goal.

Fields

Field Name	Description
`activityMode` - `String!`
`activityTypeRef` - `bigint!`	A unique, numeric identifier for the activityType.
`company` - `CompanyTP`
`name` - `String!`	A descriptive, human-readable name

Example

{
  "activityMode": "production",
  "activityTypeRef": 982312,
  "company": {"name": "Cyberdynes"},
  "name": "abc123"
}

Types

ActivityTypeField

Values

Enum Value	Description
`activityMode`
`activityTypeRef`	A unique, numeric identifier for the activityType.
`name`	A descriptive, human-readable name

Example

"activityMode"

Types

ActivityTypeOrderByClause

Fields

Input Field	Description
`activityMode` - `order_by`
`activityTypeRef` - `order_by`	A unique, numeric identifier for the activityType.
`company` - `CompanyTPOrderByClause`
`name` - `order_by`	A descriptive, human-readable name

Example

{
  "activityMode": "asc",
  "activityTypeRef": "asc",
  "company": CompanyTPOrderByClause,
  "name": "asc"
}

Types

ActivityTypeWhereClause

Fields

Input Field	Description
`_and` - `[ActivityTypeWhereClause!]`	Combines the given expressions using a logical AND
`_not` - `ActivityTypeWhereClause`	Negates the result of the given expression.
`_or` - `[ActivityTypeWhereClause!]`	Combines the given expressions using a logical OR.
`activityMode` - `StringComparison`
`activityTypeRef` - `bigintComparison`	A unique, numeric identifier for the activityType.
`company` - `CompanyTPWhereClause`
`name` - `StringComparison`	A descriptive, human-readable name

Example

{
  "_and": [ActivityTypeWhereClause],
  "_not": ActivityTypeWhereClause,
  "_or": [ActivityTypeWhereClause],
  "activityMode": StringComparison,
  "activityTypeRef": bigintComparison,
  "company": CompanyTPWhereClause,
  "name": StringComparison
}

Types

ActivityWhereClause

Fields

Input Field	Description
`_and` - `[ActivityWhereClause!]`	Combines the given expressions using a logical AND
`_not` - `ActivityWhereClause`	Negates the result of the given expression.
`_or` - `[ActivityWhereClause!]`	Combines the given expressions using a logical OR.
`activityRef` - `bigintComparison`	A unique, numeric identifier for the activity.
`activitySet` - `ActivitySetWhereClause`
`activityType` - `ActivityTypeWhereClause`
`endAt` - `timestamptzComparison`	The end of an interval. Intervals are right-exclusive.
`startAt` - `timestamptzComparison`	The start of an interval.

Example

{
  "_and": [ActivityWhereClause],
  "_not": ActivityWhereClause,
  "_or": [ActivityWhereClause],
  "activityRef": bigintComparison,
  "activitySet": ActivitySetWhereClause,
  "activityType": ActivityTypeWhereClause,
  "endAt": timestamptzComparison,
  "startAt": timestamptzComparison
}

Types

AggregatedAlarmsWhereClause

Fields

Input Field	Description
`_and` - `[AggregatedAlarmsWhereClause!]`	Combines the given expressions using a logical AND
`_not` - `AggregatedAlarmsWhereClause`	Negates the result of the given expression.
`_or` - `[AggregatedAlarmsWhereClause!]`	Combines the given expressions using a logical OR.
`bucketEndAt` - `timestamptzComparison`
`bucketStartAt` - `timestamptzComparison`
`description` - `StringComparison`
`durationMs` - `numericComparison`
`label` - `StringComparison`
`machineRef` - `IntComparison`	A unique, numeric identifier for the machine.
`maxEndAt` - `timestamptzComparison`
`minStartAt` - `timestamptzComparison`
`nativeCode` - `StringComparison`
`recordCount` - `IntComparison`
`status` - `StringComparison`

Example

{
  "_and": [AggregatedAlarmsWhereClause],
  "_not": AggregatedAlarmsWhereClause,
  "_or": [AggregatedAlarmsWhereClause],
  "bucketEndAt": timestamptzComparison,
  "bucketStartAt": timestamptzComparison,
  "description": StringComparison,
  "durationMs": numericComparison,
  "label": StringComparison,
  "machineRef": IntComparison,
  "maxEndAt": timestamptzComparison,
  "minStartAt": timestamptzComparison,
  "nativeCode": StringComparison,
  "recordCount": IntComparison,
  "status": StringComparison
}

Types

AggregatedPartCountRT

Fields

Field Name	Description
`avgValue` - `float8!`
`bucketEndAt` - `timestamptz!`
`bucketStartAt` - `timestamptz!`
`bucketWidth` - `interval!`
`eventCount` - `Int!`
`firstBucketEventTime` - `timestamptz!`
`firstValue` - `Int`
`lastBucketEventTime` - `timestamptz!`
`lastValue` - `Int`
`machine` - `MachineTP`	The machine the event originates from.
`machineRef` - `Int!`	A unique, numeric identifier for the machine.
`maxValue` - `Int`
`metricKey` - `String!`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`minValue` - `Int`
`sumOfValues` - `Int!`

Example

{
  "avgValue": 43.12,
  "bucketEndAt": "2022-05-07T01:08:03.420Z",
  "bucketStartAt": "2022-05-07T01:08:03.420Z",
  "bucketWidth": "1h",
  "eventCount": 123,
  "firstBucketEventTime": "2022-05-07T01:08:03.420Z",
  "firstValue": 123,
  "lastBucketEventTime": "2022-05-07T01:08:03.420Z",
  "lastValue": 987,
  "machine": MachineTP,
  "machineRef": 987,
  "maxValue": 123,
  "metricKey": "xyz789",
  "minValue": 987,
  "sumOfValues": 987
}

Types

AggregatedPartCountRTField

Values

Enum Value	Description
`avgValue`
`bucketEndAt`
`bucketStartAt`
`bucketWidth`
`eventCount`
`firstBucketEventTime`
`firstValue`
`lastBucketEventTime`
`lastValue`
`machineRef`	A unique, numeric identifier for the machine.
`maxValue`
`metricKey`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`minValue`
`sumOfValues`

Example

"avgValue"

Types

AggregatedPartCountRTOrderByClause

Fields

Input Field	Description
`avgValue` - `order_by`
`bucketEndAt` - `order_by`
`bucketStartAt` - `order_by`
`bucketWidth` - `order_by`
`eventCount` - `order_by`
`firstBucketEventTime` - `order_by`
`firstValue` - `order_by`
`lastBucketEventTime` - `order_by`
`lastValue` - `order_by`
`machine` - `MachineTPOrderByClause`	The machine the event originates from.
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`maxValue` - `order_by`
`metricKey` - `order_by`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`minValue` - `order_by`
`sumOfValues` - `order_by`

Example

{
  "avgValue": "asc",
  "bucketEndAt": "asc",
  "bucketStartAt": "asc",
  "bucketWidth": "asc",
  "eventCount": "asc",
  "firstBucketEventTime": "asc",
  "firstValue": "asc",
  "lastBucketEventTime": "asc",
  "lastValue": "asc",
  "machine": MachineTPOrderByClause,
  "machineRef": "asc",
  "maxValue": "asc",
  "metricKey": "asc",
  "minValue": "asc",
  "sumOfValues": "asc"
}

Types

AggregatedPartCountRTWhereClause

Fields

Input Field	Description
`_and` - `[AggregatedPartCountRTWhereClause!]`	Combines the given expressions using a logical AND
`_not` - `AggregatedPartCountRTWhereClause`	Negates the result of the given expression.
`_or` - `[AggregatedPartCountRTWhereClause!]`	Combines the given expressions using a logical OR.
`avgValue` - `float8Comparison`
`bucketEndAt` - `timestamptzComparison`
`bucketStartAt` - `timestamptzComparison`
`bucketWidth` - `intervalComparison`
`eventCount` - `IntComparison`
`firstBucketEventTime` - `timestamptzComparison`
`firstValue` - `IntComparison`
`lastBucketEventTime` - `timestamptzComparison`
`lastValue` - `IntComparison`
`machine` - `MachineTPWhereClause`	The machine the event originates from.
`machineRef` - `IntComparison`	A unique, numeric identifier for the machine.
`maxValue` - `IntComparison`
`metricKey` - `StringComparison`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`minValue` - `IntComparison`
`sumOfValues` - `IntComparison`

Example

{
  "_and": [AggregatedPartCountRTWhereClause],
  "_not": AggregatedPartCountRTWhereClause,
  "_or": [AggregatedPartCountRTWhereClause],
  "avgValue": float8Comparison,
  "bucketEndAt": timestamptzComparison,
  "bucketStartAt": timestamptzComparison,
  "bucketWidth": intervalComparison,
  "eventCount": IntComparison,
  "firstBucketEventTime": timestamptzComparison,
  "firstValue": IntComparison,
  "lastBucketEventTime": timestamptzComparison,
  "lastValue": IntComparison,
  "machine": MachineTPWhereClause,
  "machineRef": IntComparison,
  "maxValue": IntComparison,
  "metricKey": StringComparison,
  "minValue": IntComparison,
  "sumOfValues": IntComparison
}

Types

AggregatedQuantityRT

Fields

Field Name	Description
`avgValue` - `float8!`
`bucketEndAt` - `timestamptz!`
`bucketStartAt` - `timestamptz!`
`bucketWidth` - `interval!`
`eventCount` - `Int!`
`firstBucketEventTime` - `timestamptz!`
`firstValue` - `float8`
`lastBucketEventTime` - `timestamptz!`
`lastValue` - `float8`
`machine` - `MachineTP`	The machine the event originates from.
`machineRef` - `Int!`	A unique, numeric identifier for the machine.
`maxValue` - `float8`
`metricKey` - `String!`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`minValue` - `float8`
`sumOfValues` - `float8!`

Example

{
  "avgValue": 43.12,
  "bucketEndAt": "2022-05-07T01:08:03.420Z",
  "bucketStartAt": "2022-05-07T01:08:03.420Z",
  "bucketWidth": "1h",
  "eventCount": 123,
  "firstBucketEventTime": "2022-05-07T01:08:03.420Z",
  "firstValue": 43.12,
  "lastBucketEventTime": "2022-05-07T01:08:03.420Z",
  "lastValue": 43.12,
  "machine": MachineTP,
  "machineRef": 987,
  "maxValue": 43.12,
  "metricKey": "abc123",
  "minValue": 43.12,
  "sumOfValues": 43.12
}

Types

AggregatedQuantityRTOrderByClause

Fields

Input Field	Description
`avgValue` - `order_by`
`bucketEndAt` - `order_by`
`bucketStartAt` - `order_by`
`bucketWidth` - `order_by`
`eventCount` - `order_by`
`firstBucketEventTime` - `order_by`
`firstValue` - `order_by`
`lastBucketEventTime` - `order_by`
`lastValue` - `order_by`
`machine` - `MachineTPOrderByClause`	The machine the event originates from.
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`maxValue` - `order_by`
`metricKey` - `order_by`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`minValue` - `order_by`
`sumOfValues` - `order_by`

Example

{
  "avgValue": "asc",
  "bucketEndAt": "asc",
  "bucketStartAt": "asc",
  "bucketWidth": "asc",
  "eventCount": "asc",
  "firstBucketEventTime": "asc",
  "firstValue": "asc",
  "lastBucketEventTime": "asc",
  "lastValue": "asc",
  "machine": MachineTPOrderByClause,
  "machineRef": "asc",
  "maxValue": "asc",
  "metricKey": "asc",
  "minValue": "asc",
  "sumOfValues": "asc"
}

Types

AggregatedQuantityRTWhereClause

Fields

Input Field	Description
`_and` - `[AggregatedQuantityRTWhereClause!]`	Combines the given expressions using a logical AND
`_not` - `AggregatedQuantityRTWhereClause`	Negates the result of the given expression.
`_or` - `[AggregatedQuantityRTWhereClause!]`	Combines the given expressions using a logical OR.
`avgValue` - `float8Comparison`
`bucketEndAt` - `timestamptzComparison`
`bucketStartAt` - `timestamptzComparison`
`bucketWidth` - `intervalComparison`
`eventCount` - `IntComparison`
`firstBucketEventTime` - `timestamptzComparison`
`firstValue` - `float8Comparison`
`lastBucketEventTime` - `timestamptzComparison`
`lastValue` - `float8Comparison`
`machine` - `MachineTPWhereClause`	The machine the event originates from.
`machineRef` - `IntComparison`	A unique, numeric identifier for the machine.
`maxValue` - `float8Comparison`
`metricKey` - `StringComparison`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`minValue` - `float8Comparison`
`sumOfValues` - `float8Comparison`

Example

{
  "_and": [AggregatedQuantityRTWhereClause],
  "_not": AggregatedQuantityRTWhereClause,
  "_or": [AggregatedQuantityRTWhereClause],
  "avgValue": float8Comparison,
  "bucketEndAt": timestamptzComparison,
  "bucketStartAt": timestamptzComparison,
  "bucketWidth": intervalComparison,
  "eventCount": IntComparison,
  "firstBucketEventTime": timestamptzComparison,
  "firstValue": float8Comparison,
  "lastBucketEventTime": timestamptzComparison,
  "lastValue": float8Comparison,
  "machine": MachineTPWhereClause,
  "machineRef": IntComparison,
  "maxValue": float8Comparison,
  "metricKey": StringComparison,
  "minValue": float8Comparison,
  "sumOfValues": float8Comparison
}

Types

AlarmIntervalRT

Fields

Field Name	Description
`description` - `String`	A short description of the alarm.
`endAt` - `timestamptz`	The end of an interval. Intervals are right-exclusive.
`label` - `String`	The label of the alarm (one of: `NORMAL`, `WARNING`, `FAULT`, `UNAVAILABLE`)
`machine` - `MachineTP`	The machine the event originates from.
`machineRef` - `Int`	A unique, numeric identifier for the machine.
`metricKey` - `String`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`nativeCode` - `String`	The native code further specifies the alarm. The combination of `machineRef`, `metricKey`, and `nativeCode` uniquely identifies the alarm.
`sequence` - `Int`	An integer value that determines the order of events with the same `eventTime` and metric.
`startAt` - `timestamptz`	The start of an interval.

Example

{
  "description": "abc123",
  "endAt": "2022-05-07T01:08:03.420Z",
  "label": "abc123",
  "machine": MachineTP,
  "machineRef": 987,
  "metricKey": "abc123",
  "nativeCode": "xyz789",
  "sequence": 123,
  "startAt": "2022-05-07T01:08:03.420Z"
}

Types

AlarmIntervalRTField

Values

Enum Value	Description
`description`	A short description of the alarm.
`endAt`	The end of an interval. Intervals are right-exclusive.
`label`	The label of the alarm (one of: `NORMAL`, `WARNING`, `FAULT`, `UNAVAILABLE`)
`machineRef`	A unique, numeric identifier for the machine.
`metricKey`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`nativeCode`	The native code further specifies the alarm. The combination of `machineRef`, `metricKey`, and `nativeCode` uniquely identifies the alarm.
`sequence`	An integer value that determines the order of events with the same `eventTime` and metric.
`startAt`	The start of an interval.

Example

"description"

Types

AlarmIntervalRTOrderByClause

Fields

Input Field	Description
`description` - `order_by`	A short description of the alarm.
`endAt` - `order_by`	The end of an interval. Intervals are right-exclusive.
`label` - `order_by`	The label of the alarm (one of: `NORMAL`, `WARNING`, `FAULT`, `UNAVAILABLE`)
`machine` - `MachineTPOrderByClause`	The machine the event originates from.
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`metricKey` - `order_by`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`nativeCode` - `order_by`	The native code further specifies the alarm. The combination of `machineRef`, `metricKey`, and `nativeCode` uniquely identifies the alarm.
`sequence` - `order_by`	An integer value that determines the order of events with the same `eventTime` and metric.
`startAt` - `order_by`	The start of an interval.

Example

{
  "description": "asc",
  "endAt": "asc",
  "label": "asc",
  "machine": MachineTPOrderByClause,
  "machineRef": "asc",
  "metricKey": "asc",
  "nativeCode": "asc",
  "sequence": "asc",
  "startAt": "asc"
}

Types

AlarmIntervalRTWhereClause

Fields

Input Field	Description
`_and` - `[AlarmIntervalRTWhereClause!]`	Combines the given expressions using a logical AND
`_not` - `AlarmIntervalRTWhereClause`	Negates the result of the given expression.
`_or` - `[AlarmIntervalRTWhereClause!]`	Combines the given expressions using a logical OR.
`description` - `StringComparison`	A short description of the alarm.
`endAt` - `timestamptzComparison`	The end of an interval. Intervals are right-exclusive.
`label` - `StringComparison`	The label of the alarm (one of: `NORMAL`, `WARNING`, `FAULT`, `UNAVAILABLE`)
`machine` - `MachineTPWhereClause`	The machine the event originates from.
`machineRef` - `IntComparison`	A unique, numeric identifier for the machine.
`metricKey` - `StringComparison`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`nativeCode` - `StringComparison`	The native code further specifies the alarm. The combination of `machineRef`, `metricKey`, and `nativeCode` uniquely identifies the alarm.
`sequence` - `IntComparison`	An integer value that determines the order of events with the same `eventTime` and metric.
`startAt` - `timestamptzComparison`	The start of an interval.

Example

{
  "_and": [AlarmIntervalRTWhereClause],
  "_not": AlarmIntervalRTWhereClause,
  "_or": [AlarmIntervalRTWhereClause],
  "description": StringComparison,
  "endAt": timestamptzComparison,
  "label": StringComparison,
  "machine": MachineTPWhereClause,
  "machineRef": IntComparison,
  "metricKey": StringComparison,
  "nativeCode": StringComparison,
  "sequence": IntComparison,
  "startAt": timestamptzComparison
}

Types

AnnotationTP

Description

Operators, automated processes, and other members of the organization may use the MachineMetrics Operator Dashboard or Timeline in product to identify periods of downtime, label it, and provide additional context through comments. A Annotation is the data model backing a Categorized Downtime.

Fields

Field Name	Description
`annotationRef` - `Int`	A unique, numeric identifier for the annotation.
`annotationType` - `AnnotationTypeTP`
`companyId` - `String`	A globally unique identifier (UUID) for the company.
`description` - `String`
`endAt` - `timestamptz`	The end of an interval. Intervals are right-exclusive.
`isPlanned` - `Boolean`
`machine` - `MachineTP`	The machine the event originates from.
`machineRef` - `Int`	A unique, numeric identifier for the machine.
`startAt` - `timestamptz`	The start of an interval.

Example

{
  "annotationRef": 987,
  "annotationType": AnnotationTypeTP,
  "companyId": "xyz789",
  "description": "xyz789",
  "endAt": "2022-05-07T01:08:03.420Z",
  "isPlanned": false,
  "machine": MachineTP,
  "machineRef": 987,
  "startAt": "2022-05-07T01:08:03.420Z"
}

Types

AnnotationTPField

Values

Enum Value	Description
`annotationRef`	A unique, numeric identifier for the annotation.
`companyId`	A globally unique identifier (UUID) for the company.
`description`
`endAt`	The end of an interval. Intervals are right-exclusive.
`isPlanned`
`machineRef`	A unique, numeric identifier for the machine.
`startAt`	The start of an interval.

Example

"annotationRef"

Types

AnnotationTPOrderByClause

Fields

Input Field	Description
`annotationRef` - `order_by`	A unique, numeric identifier for the annotation.
`annotationType` - `AnnotationTypeTPOrderByClause`
`companyId` - `order_by`	A globally unique identifier (UUID) for the company.
`description` - `order_by`
`endAt` - `order_by`	The end of an interval. Intervals are right-exclusive.
`isPlanned` - `order_by`
`machine` - `MachineTPOrderByClause`	The machine the event originates from.
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`startAt` - `order_by`	The start of an interval.

Example

{
  "annotationRef": "asc",
  "annotationType": AnnotationTypeTPOrderByClause,
  "companyId": "asc",
  "description": "asc",
  "endAt": "asc",
  "isPlanned": "asc",
  "machine": MachineTPOrderByClause,
  "machineRef": "asc",
  "startAt": "asc"
}

Types

AnnotationTPWhereClause

Fields

Input Field	Description
`_and` - `[AnnotationTPWhereClause!]`	Combines the given expressions using a logical AND
`_not` - `AnnotationTPWhereClause`	Negates the result of the given expression.
`_or` - `[AnnotationTPWhereClause!]`	Combines the given expressions using a logical OR.
`annotationRef` - `IntComparison`	A unique, numeric identifier for the annotation.
`annotationType` - `AnnotationTypeTPWhereClause`
`companyId` - `StringComparison`	A globally unique identifier (UUID) for the company.
`description` - `StringComparison`
`endAt` - `timestamptzComparison`	The end of an interval. Intervals are right-exclusive.
`isPlanned` - `BooleanComparison`
`machine` - `MachineTPWhereClause`	The machine the event originates from.
`machineRef` - `IntComparison`	A unique, numeric identifier for the machine.
`startAt` - `timestamptzComparison`	The start of an interval.

Example

{
  "_and": [AnnotationTPWhereClause],
  "_not": AnnotationTPWhereClause,
  "_or": [AnnotationTPWhereClause],
  "annotationRef": IntComparison,
  "annotationType": AnnotationTypeTPWhereClause,
  "companyId": StringComparison,
  "description": StringComparison,
  "endAt": timestamptzComparison,
  "isPlanned": BooleanComparison,
  "machine": MachineTPWhereClause,
  "machineRef": IntComparison,
  "startAt": timestamptzComparison
}

Types

AnnotationTP_aggregateOrderByClause

Fields

Input Field	Description
`avg` - `AnnotationTP_avgOrderByClause`
`count` - `order_by`
`max` - `AnnotationTP_maxOrderByClause`
`min` - `AnnotationTP_minOrderByClause`
`stddev` - `AnnotationTP_stddevOrderByClause`
`stddev_pop` - `AnnotationTP_stddev_popOrderByClause`
`stddev_samp` - `AnnotationTP_stddev_sampOrderByClause`
`sum` - `AnnotationTP_sumOrderByClause`
`var_pop` - `AnnotationTP_var_popOrderByClause`
`var_samp` - `AnnotationTP_var_sampOrderByClause`
`variance` - `AnnotationTP_varianceOrderByClause`

Example

{
  "avg": AnnotationTP_avgOrderByClause,
  "count": "asc",
  "max": AnnotationTP_maxOrderByClause,
  "min": AnnotationTP_minOrderByClause,
  "stddev": AnnotationTP_stddevOrderByClause,
  "stddev_pop": AnnotationTP_stddev_popOrderByClause,
  "stddev_samp": AnnotationTP_stddev_sampOrderByClause,
  "sum": AnnotationTP_sumOrderByClause,
  "var_pop": AnnotationTP_var_popOrderByClause,
  "var_samp": AnnotationTP_var_sampOrderByClause,
  "variance": AnnotationTP_varianceOrderByClause
}

Types

AnnotationTP_avgOrderByClause

Fields

Input Field	Description
`annotationRef` - `order_by`	A unique, numeric identifier for the annotation.
`machineRef` - `order_by`	A unique, numeric identifier for the machine.

Example

{"annotationRef": "asc", "machineRef": "asc"}

Types

AnnotationTP_maxOrderByClause

Fields

Input Field	Description
`annotationRef` - `order_by`	A unique, numeric identifier for the annotation.
`companyId` - `order_by`	A globally unique identifier (UUID) for the company.
`description` - `order_by`
`endAt` - `order_by`	The end of an interval. Intervals are right-exclusive.
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`startAt` - `order_by`	The start of an interval.

Example

{
  "annotationRef": "asc",
  "companyId": "asc",
  "description": "asc",
  "endAt": "asc",
  "machineRef": "asc",
  "startAt": "asc"
}

Types

AnnotationTP_minOrderByClause

Fields

Input Field	Description
`annotationRef` - `order_by`	A unique, numeric identifier for the annotation.
`companyId` - `order_by`	A globally unique identifier (UUID) for the company.
`description` - `order_by`
`endAt` - `order_by`	The end of an interval. Intervals are right-exclusive.
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`startAt` - `order_by`	The start of an interval.

Example

{
  "annotationRef": "asc",
  "companyId": "asc",
  "description": "asc",
  "endAt": "asc",
  "machineRef": "asc",
  "startAt": "asc"
}

Types

AnnotationTP_stddevOrderByClause

Fields

Input Field	Description
`annotationRef` - `order_by`	A unique, numeric identifier for the annotation.
`machineRef` - `order_by`	A unique, numeric identifier for the machine.

Example

{"annotationRef": "asc", "machineRef": "asc"}

Types

AnnotationTP_stddev_popOrderByClause

Fields

Input Field	Description
`annotationRef` - `order_by`	A unique, numeric identifier for the annotation.
`machineRef` - `order_by`	A unique, numeric identifier for the machine.

Example

{"annotationRef": "asc", "machineRef": "asc"}

Types

AnnotationTP_stddev_sampOrderByClause

Fields

Input Field	Description
`annotationRef` - `order_by`	A unique, numeric identifier for the annotation.
`machineRef` - `order_by`	A unique, numeric identifier for the machine.

Example

{"annotationRef": "asc", "machineRef": "asc"}

Types

AnnotationTP_sumOrderByClause

Fields

Input Field	Description
`annotationRef` - `order_by`	A unique, numeric identifier for the annotation.
`machineRef` - `order_by`	A unique, numeric identifier for the machine.

Example

{"annotationRef": "asc", "machineRef": "asc"}

Types

AnnotationTP_var_popOrderByClause

Fields

Input Field	Description
`annotationRef` - `order_by`	A unique, numeric identifier for the annotation.
`machineRef` - `order_by`	A unique, numeric identifier for the machine.

Example

{"annotationRef": "asc", "machineRef": "asc"}

Types

AnnotationTP_var_sampOrderByClause

Fields

Input Field	Description
`annotationRef` - `order_by`	A unique, numeric identifier for the annotation.
`machineRef` - `order_by`	A unique, numeric identifier for the machine.

Example

{"annotationRef": "asc", "machineRef": "asc"}

Types

AnnotationTP_varianceOrderByClause

Fields

Input Field	Description
`annotationRef` - `order_by`	A unique, numeric identifier for the annotation.
`machineRef` - `order_by`	A unique, numeric identifier for the machine.

Example

{"annotationRef": "asc", "machineRef": "asc"}

Types

AnnotationTypeTP

Fields

Field Name	Description
`annotationTypeRef` - `Int`	A unique, numeric identifier for the annotationType.
`annotations` - `[AnnotationTP!]!`
Arguments `distinct_on` - `[AnnotationTPField!]` Return a distinct set of entities, defined by the given fields. `limit` - `Int` Limits the number of objects returned. `offset` - `Int` Start a the specified, zero-based array index. This is only useful in combination with `order_by`. `order_by` - `[AnnotationTPOrderByClause!]` Sort the returned array by one or more fields of it's elements. `where` - `AnnotationTPWhereClause` Filter the data by using a (nested) boolean expression.
`color` - `String`	The display color of the anntoation type.
`company` - `CompanyTP`
`isArchived` - `Boolean`	A boolean flag indicating whether the annotation type is archived. This affects whether it is displayed in the UI.
`name` - `String`	A descriptive, human-readable name

Example

{
  "annotationTypeRef": 123,
  "annotations": [AnnotationTP],
  "color": "xyz789",
  "company": {"name": "Cyberdynes"},
  "isArchived": true,
  "name": "xyz789"
}

Types

AnnotationTypeTPField

Values

Enum Value	Description
`annotationTypeRef`	A unique, numeric identifier for the annotationType.
`color`	The display color of the anntoation type.
`isArchived`	A boolean flag indicating whether the annotation type is archived. This affects whether it is displayed in the UI.
`name`	A descriptive, human-readable name

Example

"annotationTypeRef"

Types

AnnotationTypeTPOrderByClause

Fields

Input Field	Description
`annotationTypeRef` - `order_by`	A unique, numeric identifier for the annotationType.
`annotations_aggregate` - `AnnotationTP_aggregateOrderByClause`
`color` - `order_by`	The display color of the anntoation type.
`company` - `CompanyTPOrderByClause`
`isArchived` - `order_by`	A boolean flag indicating whether the annotation type is archived. This affects whether it is displayed in the UI.
`name` - `order_by`	A descriptive, human-readable name

Example

{
  "annotationTypeRef": "asc",
  "annotations_aggregate": AnnotationTP_aggregateOrderByClause,
  "color": "asc",
  "company": CompanyTPOrderByClause,
  "isArchived": "asc",
  "name": "asc"
}

Types

AnnotationTypeTPWhereClause

Fields

Input Field	Description
`_and` - `[AnnotationTypeTPWhereClause!]`	Combines the given expressions using a logical AND
`_not` - `AnnotationTypeTPWhereClause`	Negates the result of the given expression.
`_or` - `[AnnotationTypeTPWhereClause!]`	Combines the given expressions using a logical OR.
`annotationTypeRef` - `IntComparison`	A unique, numeric identifier for the annotationType.
`annotations` - `AnnotationTPWhereClause`
`color` - `StringComparison`	The display color of the anntoation type.
`company` - `CompanyTPWhereClause`
`isArchived` - `BooleanComparison`	A boolean flag indicating whether the annotation type is archived. This affects whether it is displayed in the UI.
`name` - `StringComparison`	A descriptive, human-readable name

Example

{
  "_and": [AnnotationTypeTPWhereClause],
  "_not": AnnotationTypeTPWhereClause,
  "_or": [AnnotationTypeTPWhereClause],
  "annotationTypeRef": IntComparison,
  "annotations": AnnotationTPWhereClause,
  "color": StringComparison,
  "company": CompanyTPWhereClause,
  "isArchived": BooleanComparison,
  "name": StringComparison
}

Types

AnnotationTypeTP_aggregateOrderByClause

Fields

Input Field	Description
`avg` - `AnnotationTypeTP_avgOrderByClause`
`count` - `order_by`
`max` - `AnnotationTypeTP_maxOrderByClause`
`min` - `AnnotationTypeTP_minOrderByClause`
`stddev` - `AnnotationTypeTP_stddevOrderByClause`
`stddev_pop` - `AnnotationTypeTP_stddev_popOrderByClause`
`stddev_samp` - `AnnotationTypeTP_stddev_sampOrderByClause`
`sum` - `AnnotationTypeTP_sumOrderByClause`
`var_pop` - `AnnotationTypeTP_var_popOrderByClause`
`var_samp` - `AnnotationTypeTP_var_sampOrderByClause`
`variance` - `AnnotationTypeTP_varianceOrderByClause`

Example

{
  "avg": AnnotationTypeTP_avgOrderByClause,
  "count": "asc",
  "max": AnnotationTypeTP_maxOrderByClause,
  "min": AnnotationTypeTP_minOrderByClause,
  "stddev": AnnotationTypeTP_stddevOrderByClause,
  "stddev_pop": AnnotationTypeTP_stddev_popOrderByClause,
  "stddev_samp": AnnotationTypeTP_stddev_sampOrderByClause,
  "sum": AnnotationTypeTP_sumOrderByClause,
  "var_pop": AnnotationTypeTP_var_popOrderByClause,
  "var_samp": AnnotationTypeTP_var_sampOrderByClause,
  "variance": AnnotationTypeTP_varianceOrderByClause
}

Types

AnnotationTypeTP_avgOrderByClause

Fields

Input Field	Description
`annotationTypeRef` - `order_by`	A unique, numeric identifier for the annotationType.

Example

{"annotationTypeRef": "asc"}

Types

AnnotationTypeTP_maxOrderByClause

Fields

Input Field	Description
`annotationTypeRef` - `order_by`	A unique, numeric identifier for the annotationType.
`color` - `order_by`	The display color of the anntoation type.
`name` - `order_by`	A descriptive, human-readable name

Example

{"annotationTypeRef": "asc", "color": "asc", "name": "asc"}

Types

AnnotationTypeTP_minOrderByClause

Fields

Input Field	Description
`annotationTypeRef` - `order_by`	A unique, numeric identifier for the annotationType.
`color` - `order_by`	The display color of the anntoation type.
`name` - `order_by`	A descriptive, human-readable name

Example

{"annotationTypeRef": "asc", "color": "asc", "name": "asc"}

Types

AnnotationTypeTP_stddevOrderByClause

Fields

Input Field	Description
`annotationTypeRef` - `order_by`	A unique, numeric identifier for the annotationType.

Example

{"annotationTypeRef": "asc"}

Types

AnnotationTypeTP_stddev_popOrderByClause

Fields

Input Field	Description
`annotationTypeRef` - `order_by`	A unique, numeric identifier for the annotationType.

Example

{"annotationTypeRef": "asc"}

Types

AnnotationTypeTP_stddev_sampOrderByClause

Fields

Input Field	Description
`annotationTypeRef` - `order_by`	A unique, numeric identifier for the annotationType.

Example

{"annotationTypeRef": "asc"}

Types

AnnotationTypeTP_sumOrderByClause

Fields

Input Field	Description
`annotationTypeRef` - `order_by`	A unique, numeric identifier for the annotationType.

Example

{"annotationTypeRef": "asc"}

Types

AnnotationTypeTP_var_popOrderByClause

Fields

Input Field	Description
`annotationTypeRef` - `order_by`	A unique, numeric identifier for the annotationType.

Example

{"annotationTypeRef": "asc"}

Types

AnnotationTypeTP_var_sampOrderByClause

Fields

Input Field	Description
`annotationTypeRef` - `order_by`	A unique, numeric identifier for the annotationType.

Example

{"annotationTypeRef": "asc"}

Types

AnnotationTypeTP_varianceOrderByClause

Fields

Input Field	Description
`annotationTypeRef` - `order_by`	A unique, numeric identifier for the annotationType.

Example

{"annotationTypeRef": "asc"}

Types

Boolean

Example

true

Types

BooleanComparison

Fields

Input Field	Description
`_eq` - `Boolean`	Returns `true` if the event value is equal to the given value; `false` otherwise.
`_gt` - `Boolean`	Returns `true` if the event value is greater than the given value; `false` otherwise.
`_gte` - `Boolean`	Returns `true` if the event value is greater than the given value; `false` otherwise.
`_in` - `[Boolean!]`	Returns `true` if the event value is equal to one of the given values in the collection; `false` otherwise.
`_is_null` - `Boolean`	Checks whether the event value is or is not `NULL`.
`_lt` - `Boolean`	Returns `true` if the event value is less than the given value; `false` otherwise.
`_lte` - `Boolean`	Returns `true` if the event value is less than the given value; `false` otherwise.
`_neq` - `Boolean`	Returns `true` if the event value is not equal to the given value; `false` otherwise.
`_nin` - `[Boolean!]`	Returns `true` if the event value is not equal to any of the given values in the collection; `false` otherwise.

Example

{
  "_eq": false,
  "_gt": false,
  "_gte": true,
  "_in": [true],
  "_is_null": true,
  "_lt": false,
  "_lte": false,
  "_neq": false,
  "_nin": [true]
}

Types

CompanyTP

Description

All data is isolated within a Company. The Machines, Annotation Types, Activity Types, Operators, and other data is scoped to this level. Information like the name, address, and timezone are available on a Company.

Fields

Field Name	Description
`activityTypes` - `[ActivityType!]!`	A set of activity types specific to the company.
Arguments `distinct_on` - `[ActivityTypeField!]` Return a distinct set of entities, defined by the given fields. `limit` - `Int` Limits the number of objects returned. `offset` - `Int` Start a the specified, zero-based array index. This is only useful in combination with `order_by`. `order_by` - `[ActivityTypeOrderByClause!]` Sort the returned array by one or more fields of it's elements. `where` - `ActivityTypeWhereClause` Filter the data by using a (nested) boolean expression.
`addressText` - `String`	The full address as as string.
`annotationTypes` - `[AnnotationTypeTP!]!`
Arguments `distinct_on` - `[AnnotationTypeTPField!]` Return a distinct set of entities, defined by the given fields. `limit` - `Int` Limits the number of objects returned. `offset` - `Int` Start a the specified, zero-based array index. This is only useful in combination with `order_by`. `order_by` - `[AnnotationTypeTPOrderByClause!]` Sort the returned array by one or more fields of it's elements. `where` - `AnnotationTypeTPWhereClause` Filter the data by using a (nested) boolean expression.
`companyId` - `String`	A globally unique identifier (UUID) for the company.
`machines` - `[MachineTP!]!`	The set machines.
Arguments `distinct_on` - `[MachineTPField!]` Return a distinct set of entities, defined by the given fields. `limit` - `Int` Limits the number of objects returned. `offset` - `Int` Start a the specified, zero-based array index. This is only useful in combination with `order_by`. `order_by` - `[MachineTPOrderByClause!]` Sort the returned array by one or more fields of it's elements. `where` - `MachineTPWhereClause` Filter the data by using a (nested) boolean expression.
`name` - `String`	A descriptive, human-readable name
`operations` - `[Operation!]!`
Arguments `distinct_on` - `[OperationField!]` Return a distinct set of entities, defined by the given fields. `limit` - `Int` Limits the number of objects returned. `offset` - `Int` Start a the specified, zero-based array index. This is only useful in combination with `order_by`. `order_by` - `[OperationOrderByClause!]` Sort the returned array by one or more fields of it's elements. `where` - `OperationWhereClause` Filter the data by using a (nested) boolean expression.
`operators` - `[OperatorTP!]!`	Returns a collection of Operators
Arguments `distinct_on` - `[OperatorTPField!]` Return a distinct set of entities, defined by the given fields. `limit` - `Int` Limits the number of objects returned. `offset` - `Int` Start a the specified, zero-based array index. This is only useful in combination with `order_by`. `order_by` - `[OperatorTPOrderByClause!]` Sort the returned array by one or more fields of it's elements. `where` - `OperatorTPWhereClause` Filter the data by using a (nested) boolean expression.
`rejectReasons` - `[RejectReason!]!`	A set of reject reasons specific to the company.
Arguments `distinct_on` - `[RejectReasonField!]` Return a distinct set of entities, defined by the given fields. `limit` - `Int` Limits the number of objects returned. `offset` - `Int` Start a the specified, zero-based array index. This is only useful in combination with `order_by`. `order_by` - `[RejectReasonOrderByClause!]` Sort the returned array by one or more fields of it's elements. `where` - `RejectReasonWhereClause` Filter the data by using a (nested) boolean expression.
`timeZone` - `String`	The timezone the company is associated with. Must be an

Example

{"name": "Cyberdynes"}

Types

CompanyTPOrderByClause

Fields

Input Field	Description
`addressText` - `order_by`	The full address as as string.
`annotationTypes_aggregate` - `AnnotationTypeTP_aggregateOrderByClause`
`companyId` - `order_by`	A globally unique identifier (UUID) for the company.
`name` - `order_by`	A descriptive, human-readable name
`timeZone` - `order_by`	The timezone the company is associated with. Must be an

Example

{
  "addressText": "asc",
  "annotationTypes_aggregate": AnnotationTypeTP_aggregateOrderByClause,
  "companyId": "asc",
  "name": "asc",
  "timeZone": "asc"
}

Types

CompanyTPWhereClause

Fields

Input Field	Description
`_and` - `[CompanyTPWhereClause!]`	Combines the given expressions using a logical AND
`_not` - `CompanyTPWhereClause`	Negates the result of the given expression.
`_or` - `[CompanyTPWhereClause!]`	Combines the given expressions using a logical OR.
`activityTypes` - `ActivityTypeWhereClause`	A set of activity types specific to the company.
`addressText` - `StringComparison`	The full address as as string.
`annotationTypes` - `AnnotationTypeTPWhereClause`
`companyId` - `StringComparison`	A globally unique identifier (UUID) for the company.
`machines` - `MachineTPWhereClause`	The set machines.
`name` - `StringComparison`	A descriptive, human-readable name
`operations` - `OperationWhereClause`
`operators` - `OperatorTPWhereClause`	Returns a collection of Operators
`rejectReasons` - `RejectReasonWhereClause`	A set of reject reasons specific to the company.
`timeZone` - `StringComparison`	The timezone the company is associated with. Must be an

Example

{
  "_and": [CompanyTPWhereClause],
  "_not": CompanyTPWhereClause,
  "_or": [CompanyTPWhereClause],
  "activityTypes": ActivityTypeWhereClause,
  "addressText": StringComparison,
  "annotationTypes": AnnotationTypeTPWhereClause,
  "companyId": StringComparison,
  "machines": MachineTPWhereClause,
  "name": StringComparison,
  "operations": OperationWhereClause,
  "operators": OperatorTPWhereClause,
  "rejectReasons": RejectReasonWhereClause,
  "timeZone": StringComparison
}

Types

CurrentAlarmRT

Fields

Field Name	Description
`description` - `String`
`label` - `String`
`latestEventAt` - `timestamptz!`
`machine` - `MachineTP`	The machine the event originates from.
`machineRef` - `Int`	A unique, numeric identifier for the machine.
`metricKey` - `String`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`nativeCode` - `String`
`startAt` - `timestamptz`	The start of an interval.

Example

{
  "description": "xyz789",
  "label": "xyz789",
  "latestEventAt": "2022-05-07T01:08:03.420Z",
  "machine": MachineTP,
  "machineRef": 987,
  "metricKey": "abc123",
  "nativeCode": "xyz789",
  "startAt": "2022-05-07T01:08:03.420Z"
}

Types

CurrentAlarmRTField

Values

Enum Value	Description
`description`
`label`
`latestEventAt`
`machineRef`	A unique, numeric identifier for the machine.
`metricKey`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`nativeCode`
`startAt`	The start of an interval.

Example

"description"

Types

CurrentAlarmRTOrderByClause

Fields

Input Field	Description
`description` - `order_by`
`label` - `order_by`
`latestEventAt` - `order_by`
`machine` - `MachineTPOrderByClause`	The machine the event originates from.
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`metricKey` - `order_by`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`nativeCode` - `order_by`
`startAt` - `order_by`	The start of an interval.

Example

{
  "description": "asc",
  "label": "asc",
  "latestEventAt": "asc",
  "machine": MachineTPOrderByClause,
  "machineRef": "asc",
  "metricKey": "asc",
  "nativeCode": "asc",
  "startAt": "asc"
}

Types

CurrentAlarmRTWhereClause

Fields

Input Field	Description
`_and` - `[CurrentAlarmRTWhereClause!]`	Combines the given expressions using a logical AND
`_not` - `CurrentAlarmRTWhereClause`	Negates the result of the given expression.
`_or` - `[CurrentAlarmRTWhereClause!]`	Combines the given expressions using a logical OR.
`description` - `StringComparison`
`label` - `StringComparison`
`latestEventAt` - `timestamptzComparison`
`machine` - `MachineTPWhereClause`	The machine the event originates from.
`machineRef` - `IntComparison`	A unique, numeric identifier for the machine.
`metricKey` - `StringComparison`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`nativeCode` - `StringComparison`
`startAt` - `timestamptzComparison`	The start of an interval.

Example

{
  "_and": [CurrentAlarmRTWhereClause],
  "_not": CurrentAlarmRTWhereClause,
  "_or": [CurrentAlarmRTWhereClause],
  "description": StringComparison,
  "label": StringComparison,
  "latestEventAt": timestamptzComparison,
  "machine": MachineTPWhereClause,
  "machineRef": IntComparison,
  "metricKey": StringComparison,
  "nativeCode": StringComparison,
  "startAt": timestamptzComparison
}

Types

CurrentAlarmRT_aggregateOrderByClause

Fields

Input Field	Description
`avg` - `CurrentAlarmRT_avgOrderByClause`
`count` - `order_by`
`max` - `CurrentAlarmRT_maxOrderByClause`
`min` - `CurrentAlarmRT_minOrderByClause`
`stddev` - `CurrentAlarmRT_stddevOrderByClause`
`stddev_pop` - `CurrentAlarmRT_stddev_popOrderByClause`
`stddev_samp` - `CurrentAlarmRT_stddev_sampOrderByClause`
`sum` - `CurrentAlarmRT_sumOrderByClause`
`var_pop` - `CurrentAlarmRT_var_popOrderByClause`
`var_samp` - `CurrentAlarmRT_var_sampOrderByClause`
`variance` - `CurrentAlarmRT_varianceOrderByClause`

Example

{
  "avg": CurrentAlarmRT_avgOrderByClause,
  "count": "asc",
  "max": CurrentAlarmRT_maxOrderByClause,
  "min": CurrentAlarmRT_minOrderByClause,
  "stddev": CurrentAlarmRT_stddevOrderByClause,
  "stddev_pop": CurrentAlarmRT_stddev_popOrderByClause,
  "stddev_samp": CurrentAlarmRT_stddev_sampOrderByClause,
  "sum": CurrentAlarmRT_sumOrderByClause,
  "var_pop": CurrentAlarmRT_var_popOrderByClause,
  "var_samp": CurrentAlarmRT_var_sampOrderByClause,
  "variance": CurrentAlarmRT_varianceOrderByClause
}

Types

CurrentAlarmRT_avgOrderByClause

Fields

Input Field	Description
`machineRef` - `order_by`	A unique, numeric identifier for the machine.

Example

{"machineRef": "asc"}

Types

CurrentAlarmRT_maxOrderByClause

Fields

Input Field	Description
`description` - `order_by`
`label` - `order_by`
`latestEventAt` - `order_by`
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`metricKey` - `order_by`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`nativeCode` - `order_by`
`startAt` - `order_by`	The start of an interval.

Example

{
  "description": "asc",
  "label": "asc",
  "latestEventAt": "asc",
  "machineRef": "asc",
  "metricKey": "asc",
  "nativeCode": "asc",
  "startAt": "asc"
}

Types

CurrentAlarmRT_minOrderByClause

Fields

Input Field	Description
`description` - `order_by`
`label` - `order_by`
`latestEventAt` - `order_by`
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`metricKey` - `order_by`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`nativeCode` - `order_by`
`startAt` - `order_by`	The start of an interval.

Example

{
  "description": "asc",
  "label": "asc",
  "latestEventAt": "asc",
  "machineRef": "asc",
  "metricKey": "asc",
  "nativeCode": "asc",
  "startAt": "asc"
}

Types

CurrentAlarmRT_stddevOrderByClause

Fields

Input Field	Description
`machineRef` - `order_by`	A unique, numeric identifier for the machine.

Example

{"machineRef": "asc"}

Types

CurrentAlarmRT_stddev_popOrderByClause

Fields

Input Field	Description
`machineRef` - `order_by`	A unique, numeric identifier for the machine.

Example

{"machineRef": "asc"}

Types

CurrentAlarmRT_stddev_sampOrderByClause

Fields

Input Field	Description
`machineRef` - `order_by`	A unique, numeric identifier for the machine.

Example

{"machineRef": "asc"}

Types

CurrentAlarmRT_sumOrderByClause

Fields

Input Field	Description
`machineRef` - `order_by`	A unique, numeric identifier for the machine.

Example

{"machineRef": "asc"}

Types

CurrentAlarmRT_var_popOrderByClause

Fields

Input Field	Description
`machineRef` - `order_by`	A unique, numeric identifier for the machine.

Example

{"machineRef": "asc"}

Types

CurrentAlarmRT_var_sampOrderByClause

Fields

Input Field	Description
`machineRef` - `order_by`	A unique, numeric identifier for the machine.

Example

{"machineRef": "asc"}

Types

CurrentAlarmRT_varianceOrderByClause

Fields

Input Field	Description
`machineRef` - `order_by`	A unique, numeric identifier for the machine.

Example

{"machineRef": "asc"}

Types

CurrentStateRT

Fields

Field Name	Description
`latestEventAt` - `timestamptz!`
`machine` - `MachineTP`	The machine the event originates from.
`machineRef` - `Int`	A unique, numeric identifier for the machine.
`metricKey` - `String`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`startAt` - `timestamptz`	The start of an interval.
`value` - `String`	The value observed at the `eventTime`.

Example

{
  "latestEventAt": "2022-05-07T01:08:03.420Z",
  "machine": MachineTP,
  "machineRef": 123,
  "metricKey": "abc123",
  "startAt": "2022-05-07T01:08:03.420Z",
  "value": "xyz789"
}

Types

CurrentStateRTField

Values

Enum Value	Description
`latestEventAt`
`machineRef`	A unique, numeric identifier for the machine.
`metricKey`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`startAt`	The start of an interval.
`value`	The value observed at the `eventTime`.

Example

"latestEventAt"

Types

CurrentStateRTOrderByClause

Fields

Input Field	Description
`latestEventAt` - `order_by`
`machine` - `MachineTPOrderByClause`	The machine the event originates from.
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`metricKey` - `order_by`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`startAt` - `order_by`	The start of an interval.
`value` - `order_by`	The value observed at the `eventTime`.

Example

{
  "latestEventAt": "asc",
  "machine": MachineTPOrderByClause,
  "machineRef": "asc",
  "metricKey": "asc",
  "startAt": "asc",
  "value": "asc"
}

Types

CurrentStateRTWhereClause

Fields

Input Field	Description
`_and` - `[CurrentStateRTWhereClause!]`	Combines the given expressions using a logical AND
`_not` - `CurrentStateRTWhereClause`	Negates the result of the given expression.
`_or` - `[CurrentStateRTWhereClause!]`	Combines the given expressions using a logical OR.
`latestEventAt` - `timestamptzComparison`
`machine` - `MachineTPWhereClause`	The machine the event originates from.
`machineRef` - `IntComparison`	A unique, numeric identifier for the machine.
`metricKey` - `StringComparison`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`startAt` - `timestamptzComparison`	The start of an interval.
`value` - `StringComparison`	The value observed at the `eventTime`.

Example

{
  "_and": [CurrentStateRTWhereClause],
  "_not": CurrentStateRTWhereClause,
  "_or": [CurrentStateRTWhereClause],
  "latestEventAt": timestamptzComparison,
  "machine": MachineTPWhereClause,
  "machineRef": IntComparison,
  "metricKey": StringComparison,
  "startAt": timestamptzComparison,
  "value": StringComparison
}

Types

CurrentStateRT_aggregateOrderByClause

Fields

Input Field	Description
`avg` - `CurrentStateRT_avgOrderByClause`
`count` - `order_by`
`max` - `CurrentStateRT_maxOrderByClause`
`min` - `CurrentStateRT_minOrderByClause`
`stddev` - `CurrentStateRT_stddevOrderByClause`
`stddev_pop` - `CurrentStateRT_stddev_popOrderByClause`
`stddev_samp` - `CurrentStateRT_stddev_sampOrderByClause`
`sum` - `CurrentStateRT_sumOrderByClause`
`var_pop` - `CurrentStateRT_var_popOrderByClause`
`var_samp` - `CurrentStateRT_var_sampOrderByClause`
`variance` - `CurrentStateRT_varianceOrderByClause`

Example

{
  "avg": CurrentStateRT_avgOrderByClause,
  "count": "asc",
  "max": CurrentStateRT_maxOrderByClause,
  "min": CurrentStateRT_minOrderByClause,
  "stddev": CurrentStateRT_stddevOrderByClause,
  "stddev_pop": CurrentStateRT_stddev_popOrderByClause,
  "stddev_samp": CurrentStateRT_stddev_sampOrderByClause,
  "sum": CurrentStateRT_sumOrderByClause,
  "var_pop": CurrentStateRT_var_popOrderByClause,
  "var_samp": CurrentStateRT_var_sampOrderByClause,
  "variance": CurrentStateRT_varianceOrderByClause
}

Types

CurrentStateRT_avgOrderByClause

Fields

Input Field	Description
`machineRef` - `order_by`	A unique, numeric identifier for the machine.

Example

{"machineRef": "asc"}

Types

CurrentStateRT_maxOrderByClause

Fields

Input Field	Description
`latestEventAt` - `order_by`
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`metricKey` - `order_by`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`startAt` - `order_by`	The start of an interval.
`value` - `order_by`	The value observed at the `eventTime`.

Example

{
  "latestEventAt": "asc",
  "machineRef": "asc",
  "metricKey": "asc",
  "startAt": "asc",
  "value": "asc"
}

Types

CurrentStateRT_minOrderByClause

Fields

Input Field	Description
`latestEventAt` - `order_by`
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`metricKey` - `order_by`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`startAt` - `order_by`	The start of an interval.
`value` - `order_by`	The value observed at the `eventTime`.

Example

{
  "latestEventAt": "asc",
  "machineRef": "asc",
  "metricKey": "asc",
  "startAt": "asc",
  "value": "asc"
}

Types

CurrentStateRT_stddevOrderByClause

Fields

Input Field	Description
`machineRef` - `order_by`	A unique, numeric identifier for the machine.

Example

{"machineRef": "asc"}

Types

CurrentStateRT_stddev_popOrderByClause

Fields

Input Field	Description
`machineRef` - `order_by`	A unique, numeric identifier for the machine.

Example

{"machineRef": "asc"}

Types

CurrentStateRT_stddev_sampOrderByClause

Fields

Input Field	Description
`machineRef` - `order_by`	A unique, numeric identifier for the machine.

Example

{"machineRef": "asc"}

Types

CurrentStateRT_sumOrderByClause

Fields

Input Field	Description
`machineRef` - `order_by`	A unique, numeric identifier for the machine.

Example

{"machineRef": "asc"}

Types

CurrentStateRT_var_popOrderByClause

Fields

Input Field	Description
`machineRef` - `order_by`	A unique, numeric identifier for the machine.

Example

{"machineRef": "asc"}

Types

CurrentStateRT_var_sampOrderByClause

Fields

Input Field	Description
`machineRef` - `order_by`	A unique, numeric identifier for the machine.

Example

{"machineRef": "asc"}

Types

CurrentStateRT_varianceOrderByClause

Fields

Input Field	Description
`machineRef` - `order_by`	A unique, numeric identifier for the machine.

Example

{"machineRef": "asc"}

Types

Int

Example

Types

IntComparison

Fields

Input Field	Description
`_eq` - `Int`	Returns `true` if the event value is equal to the given value; `false` otherwise.
`_gt` - `Int`	Returns `true` if the event value is greater than the given value; `false` otherwise.
`_gte` - `Int`	Returns `true` if the event value is greater than the given value; `false` otherwise.
`_in` - `[Int!]`	Returns `true` if the event value is equal to one of the given values in the collection; `false` otherwise.
`_is_null` - `Boolean`	Checks whether the event value is or is not `NULL`.
`_lt` - `Int`	Returns `true` if the event value is less than the given value; `false` otherwise.
`_lte` - `Int`	Returns `true` if the event value is less than the given value; `false` otherwise.
`_neq` - `Int`	Returns `true` if the event value is not equal to the given value; `false` otherwise.
`_nin` - `[Int!]`	Returns `true` if the event value is not equal to any of the given values in the collection; `false` otherwise.

Example

{
  "_eq": 987,
  "_gt": 123,
  "_gte": 987,
  "_in": [987],
  "_is_null": true,
  "_lt": 987,
  "_lte": 123,
  "_neq": 987,
  "_nin": [987]
}

Types

LatestPositionRT

Fields

Field Name	Description
`eventTime` - `timestamptz`
`machine` - `MachineTP`	The machine the event originates from.
`machineRef` - `Int`	A unique, numeric identifier for the machine.
`metricKey` - `String`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`x` - `float8`	The x coordinate value.
`y` - `float8`	The y coordinate value.
`z` - `float8`	The z coordinate value.

Example

{
  "eventTime": "2022-05-07T01:08:03.420Z",
  "machine": MachineTP,
  "machineRef": 123,
  "metricKey": "xyz789",
  "x": 43.12,
  "y": 43.12,
  "z": 43.12
}

Types

LatestPositionRTField

Values

Enum Value	Description
`eventTime`
`machineRef`	A unique, numeric identifier for the machine.
`metricKey`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`x`	The x coordinate value.
`y`	The y coordinate value.
`z`	The z coordinate value.

Example

"eventTime"

Types

LatestPositionRTOrderByClause

Fields

Input Field	Description
`eventTime` - `order_by`
`machine` - `MachineTPOrderByClause`	The machine the event originates from.
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`metricKey` - `order_by`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`x` - `order_by`	The x coordinate value.
`y` - `order_by`	The y coordinate value.
`z` - `order_by`	The z coordinate value.

Example

{
  "eventTime": "asc",
  "machine": MachineTPOrderByClause,
  "machineRef": "asc",
  "metricKey": "asc",
  "x": "asc",
  "y": "asc",
  "z": "asc"
}

Types

LatestPositionRTWhereClause

Fields

Input Field	Description
`_and` - `[LatestPositionRTWhereClause!]`	Combines the given expressions using a logical AND
`_not` - `LatestPositionRTWhereClause`	Negates the result of the given expression.
`_or` - `[LatestPositionRTWhereClause!]`	Combines the given expressions using a logical OR.
`eventTime` - `timestamptzComparison`
`machine` - `MachineTPWhereClause`	The machine the event originates from.
`machineRef` - `IntComparison`	A unique, numeric identifier for the machine.
`metricKey` - `StringComparison`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`x` - `float8Comparison`	The x coordinate value.
`y` - `float8Comparison`	The y coordinate value.
`z` - `float8Comparison`	The z coordinate value.

Example

{
  "_and": [LatestPositionRTWhereClause],
  "_not": LatestPositionRTWhereClause,
  "_or": [LatestPositionRTWhereClause],
  "eventTime": timestamptzComparison,
  "machine": MachineTPWhereClause,
  "machineRef": IntComparison,
  "metricKey": StringComparison,
  "x": float8Comparison,
  "y": float8Comparison,
  "z": float8Comparison
}

Types

LatestPositionRT_aggregateOrderByClause

Fields

Input Field	Description
`avg` - `LatestPositionRT_avgOrderByClause`
`count` - `order_by`
`max` - `LatestPositionRT_maxOrderByClause`
`min` - `LatestPositionRT_minOrderByClause`
`stddev` - `LatestPositionRT_stddevOrderByClause`
`stddev_pop` - `LatestPositionRT_stddev_popOrderByClause`
`stddev_samp` - `LatestPositionRT_stddev_sampOrderByClause`
`sum` - `LatestPositionRT_sumOrderByClause`
`var_pop` - `LatestPositionRT_var_popOrderByClause`
`var_samp` - `LatestPositionRT_var_sampOrderByClause`
`variance` - `LatestPositionRT_varianceOrderByClause`

Example

{
  "avg": LatestPositionRT_avgOrderByClause,
  "count": "asc",
  "max": LatestPositionRT_maxOrderByClause,
  "min": LatestPositionRT_minOrderByClause,
  "stddev": LatestPositionRT_stddevOrderByClause,
  "stddev_pop": LatestPositionRT_stddev_popOrderByClause,
  "stddev_samp": LatestPositionRT_stddev_sampOrderByClause,
  "sum": LatestPositionRT_sumOrderByClause,
  "var_pop": LatestPositionRT_var_popOrderByClause,
  "var_samp": LatestPositionRT_var_sampOrderByClause,
  "variance": LatestPositionRT_varianceOrderByClause
}

Types

LatestPositionRT_avgOrderByClause

Fields

Input Field	Description
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`x` - `order_by`	The x coordinate value.
`y` - `order_by`	The y coordinate value.
`z` - `order_by`	The z coordinate value.

Example

{"machineRef": "asc", "x": "asc", "y": "asc", "z": "asc"}

Types

LatestPositionRT_maxOrderByClause

Fields

Input Field	Description
`eventTime` - `order_by`
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`metricKey` - `order_by`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`x` - `order_by`	The x coordinate value.
`y` - `order_by`	The y coordinate value.
`z` - `order_by`	The z coordinate value.

Example

{
  "eventTime": "asc",
  "machineRef": "asc",
  "metricKey": "asc",
  "x": "asc",
  "y": "asc",
  "z": "asc"
}

Types

LatestPositionRT_minOrderByClause

Fields

Input Field	Description
`eventTime` - `order_by`
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`metricKey` - `order_by`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`x` - `order_by`	The x coordinate value.
`y` - `order_by`	The y coordinate value.
`z` - `order_by`	The z coordinate value.

Example

{
  "eventTime": "asc",
  "machineRef": "asc",
  "metricKey": "asc",
  "x": "asc",
  "y": "asc",
  "z": "asc"
}

Types

LatestPositionRT_stddevOrderByClause

Fields

Input Field	Description
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`x` - `order_by`	The x coordinate value.
`y` - `order_by`	The y coordinate value.
`z` - `order_by`	The z coordinate value.

Example

{"machineRef": "asc", "x": "asc", "y": "asc", "z": "asc"}

Types

LatestPositionRT_stddev_popOrderByClause

Fields

Input Field	Description
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`x` - `order_by`	The x coordinate value.
`y` - `order_by`	The y coordinate value.
`z` - `order_by`	The z coordinate value.

Example

{"machineRef": "asc", "x": "asc", "y": "asc", "z": "asc"}

Types

LatestPositionRT_stddev_sampOrderByClause

Fields

Input Field	Description
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`x` - `order_by`	The x coordinate value.
`y` - `order_by`	The y coordinate value.
`z` - `order_by`	The z coordinate value.

Example

{"machineRef": "asc", "x": "asc", "y": "asc", "z": "asc"}

Types

LatestPositionRT_sumOrderByClause

Fields

Input Field	Description
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`x` - `order_by`	The x coordinate value.
`y` - `order_by`	The y coordinate value.
`z` - `order_by`	The z coordinate value.

Example

{"machineRef": "asc", "x": "asc", "y": "asc", "z": "asc"}

Types

LatestPositionRT_var_popOrderByClause

Fields

Input Field	Description
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`x` - `order_by`	The x coordinate value.
`y` - `order_by`	The y coordinate value.
`z` - `order_by`	The z coordinate value.

Example

{"machineRef": "asc", "x": "asc", "y": "asc", "z": "asc"}

Types

LatestPositionRT_var_sampOrderByClause

Fields

Input Field	Description
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`x` - `order_by`	The x coordinate value.
`y` - `order_by`	The y coordinate value.
`z` - `order_by`	The z coordinate value.

Example

{"machineRef": "asc", "x": "asc", "y": "asc", "z": "asc"}

Types

LatestPositionRT_varianceOrderByClause

Fields

Input Field	Description
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`x` - `order_by`	The x coordinate value.
`y` - `order_by`	The y coordinate value.
`z` - `order_by`	The z coordinate value.

Example

{"machineRef": "asc", "x": "asc", "y": "asc", "z": "asc"}

Types

LatestQuantityRT

Fields

Field Name	Description
`eventTime` - `timestamptz`
`machine` - `MachineTP`	The machine the event originates from.
`machineRef` - `Int`	A unique, numeric identifier for the machine.
`metricKey` - `String`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`sequence` - `Int`	An integer value that determines the order of events with the same `eventTime` and metric.
`value` - `float8`	The value observed at the `eventTime`.

Example

{
  "eventTime": "2022-05-07T01:08:03.420Z",
  "machine": MachineTP,
  "machineRef": 987,
  "metricKey": "xyz789",
  "sequence": 987,
  "value": 43.12
}

Types

LatestQuantityRTField

Values

Enum Value	Description
`eventTime`
`machineRef`	A unique, numeric identifier for the machine.
`metricKey`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`sequence`	An integer value that determines the order of events with the same `eventTime` and metric.
`value`	The value observed at the `eventTime`.

Example

"eventTime"

Types

LatestQuantityRTWhereClause

Fields

Input Field	Description
`_and` - `[LatestQuantityRTWhereClause!]`	Combines the given expressions using a logical AND
`_not` - `LatestQuantityRTWhereClause`	Negates the result of the given expression.
`_or` - `[LatestQuantityRTWhereClause!]`	Combines the given expressions using a logical OR.
`eventTime` - `timestamptzComparison`
`machine` - `MachineTPWhereClause`	The machine the event originates from.
`machineRef` - `IntComparison`	A unique, numeric identifier for the machine.
`metricKey` - `StringComparison`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`sequence` - `IntComparison`	An integer value that determines the order of events with the same `eventTime` and metric.
`value` - `float8Comparison`	The value observed at the `eventTime`.

Example

{
  "_and": [LatestQuantityRTWhereClause],
  "_not": LatestQuantityRTWhereClause,
  "_or": [LatestQuantityRTWhereClause],
  "eventTime": timestamptzComparison,
  "machine": MachineTPWhereClause,
  "machineRef": IntComparison,
  "metricKey": StringComparison,
  "sequence": IntComparison,
  "value": float8Comparison
}

Types

LatestQuantityRT_aggregateOrderByClause

Fields

Input Field	Description
`avg` - `LatestQuantityRT_avgOrderByClause`
`count` - `order_by`
`max` - `LatestQuantityRT_maxOrderByClause`
`min` - `LatestQuantityRT_minOrderByClause`
`stddev` - `LatestQuantityRT_stddevOrderByClause`
`stddev_pop` - `LatestQuantityRT_stddev_popOrderByClause`
`stddev_samp` - `LatestQuantityRT_stddev_sampOrderByClause`
`sum` - `LatestQuantityRT_sumOrderByClause`
`var_pop` - `LatestQuantityRT_var_popOrderByClause`
`var_samp` - `LatestQuantityRT_var_sampOrderByClause`
`variance` - `LatestQuantityRT_varianceOrderByClause`

Example

{
  "avg": LatestQuantityRT_avgOrderByClause,
  "count": "asc",
  "max": LatestQuantityRT_maxOrderByClause,
  "min": LatestQuantityRT_minOrderByClause,
  "stddev": LatestQuantityRT_stddevOrderByClause,
  "stddev_pop": LatestQuantityRT_stddev_popOrderByClause,
  "stddev_samp": LatestQuantityRT_stddev_sampOrderByClause,
  "sum": LatestQuantityRT_sumOrderByClause,
  "var_pop": LatestQuantityRT_var_popOrderByClause,
  "var_samp": LatestQuantityRT_var_sampOrderByClause,
  "variance": LatestQuantityRT_varianceOrderByClause
}

Types

LatestQuantityRT_avgOrderByClause

Fields

Input Field	Description
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`sequence` - `order_by`	An integer value that determines the order of events with the same `eventTime` and metric.
`value` - `order_by`	The value observed at the `eventTime`.

Example

{"machineRef": "asc", "sequence": "asc", "value": "asc"}

Types

LatestQuantityRT_maxOrderByClause

Fields

Input Field	Description
`eventTime` - `order_by`
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`metricKey` - `order_by`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`sequence` - `order_by`	An integer value that determines the order of events with the same `eventTime` and metric.
`value` - `order_by`	The value observed at the `eventTime`.

Example

{
  "eventTime": "asc",
  "machineRef": "asc",
  "metricKey": "asc",
  "sequence": "asc",
  "value": "asc"
}

Types

LatestQuantityRT_minOrderByClause

Fields

Input Field	Description
`eventTime` - `order_by`
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`metricKey` - `order_by`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`sequence` - `order_by`	An integer value that determines the order of events with the same `eventTime` and metric.
`value` - `order_by`	The value observed at the `eventTime`.

Example

{
  "eventTime": "asc",
  "machineRef": "asc",
  "metricKey": "asc",
  "sequence": "asc",
  "value": "asc"
}

Types

LatestQuantityRT_stddevOrderByClause

Fields

Input Field	Description
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`sequence` - `order_by`	An integer value that determines the order of events with the same `eventTime` and metric.
`value` - `order_by`	The value observed at the `eventTime`.

Example

{"machineRef": "asc", "sequence": "asc", "value": "asc"}

Types

LatestQuantityRT_stddev_popOrderByClause

Fields

Input Field	Description
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`sequence` - `order_by`	An integer value that determines the order of events with the same `eventTime` and metric.
`value` - `order_by`	The value observed at the `eventTime`.

Example

{"machineRef": "asc", "sequence": "asc", "value": "asc"}

Types

LatestQuantityRT_stddev_sampOrderByClause

Fields

Input Field	Description
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`sequence` - `order_by`	An integer value that determines the order of events with the same `eventTime` and metric.
`value` - `order_by`	The value observed at the `eventTime`.

Example

{"machineRef": "asc", "sequence": "asc", "value": "asc"}

Types

LatestQuantityRT_sumOrderByClause

Fields

Input Field	Description
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`sequence` - `order_by`	An integer value that determines the order of events with the same `eventTime` and metric.
`value` - `order_by`	The value observed at the `eventTime`.

Example

{"machineRef": "asc", "sequence": "asc", "value": "asc"}

Types

LatestQuantityRT_var_popOrderByClause

Fields

Input Field	Description
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`sequence` - `order_by`	An integer value that determines the order of events with the same `eventTime` and metric.
`value` - `order_by`	The value observed at the `eventTime`.

Example

{"machineRef": "asc", "sequence": "asc", "value": "asc"}

Types

LatestQuantityRT_var_sampOrderByClause

Fields

Input Field	Description
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`sequence` - `order_by`	An integer value that determines the order of events with the same `eventTime` and metric.
`value` - `order_by`	The value observed at the `eventTime`.

Example

{"machineRef": "asc", "sequence": "asc", "value": "asc"}

Types

LatestQuantityRT_varianceOrderByClause

Fields

Input Field	Description
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`sequence` - `order_by`	An integer value that determines the order of events with the same `eventTime` and metric.
`value` - `order_by`	The value observed at the `eventTime`.

Example

{"machineRef": "asc", "sequence": "asc", "value": "asc"}

Types

MachineTP

Description

A Machine is at the heart of it all. All business-related operational data stems from the Machine. Annotations represent categorized periods of time when the Machine was idle. Activities capture slices of time where the Machine was performing a particular Operation. Operator Runs represent when a specific Operator was responsible for a given Machine’s productivity. This operational data can be driven by human input, but is also often driven by diagnostic data reported directly from the Machine itself. The most relevant machine data comes in the form of States, Part Counts, and Alarms.

Fields

Field Name	Description
`activitySets` - `[ActivitySet!]!`
Arguments `distinct_on` - `[ActivitySetField!]` Return a distinct set of entities, defined by the given fields. `limit` - `Int` Limits the number of objects returned. `offset` - `Int` Start a the specified, zero-based array index. This is only useful in combination with `order_by`. `order_by` - `[ActivitySetOrderByClause!]` Sort the returned array by one or more fields of it's elements. `where` - `ActivitySetWhereClause` Filter the data by using a (nested) boolean expression.
`annotations` - `[AnnotationTP!]!`
Arguments `distinct_on` - `[AnnotationTPField!]` Return a distinct set of entities, defined by the given fields. `limit` - `Int` Limits the number of objects returned. `offset` - `Int` Start a the specified, zero-based array index. This is only useful in combination with `order_by`. `order_by` - `[AnnotationTPOrderByClause!]` Sort the returned array by one or more fields of it's elements. `where` - `AnnotationTPWhereClause` Filter the data by using a (nested) boolean expression.
`company` - `CompanyTP`
`currentAlarms` - `[CurrentAlarmRT!]`
Arguments `distinct_on` - `[CurrentAlarmRTField!]` Return a distinct set of entities, defined by the given fields. `limit` - `Int` Limits the number of objects returned. `offset` - `Int` Start a the specified, zero-based array index. This is only useful in combination with `order_by`. `order_by` - `[CurrentAlarmRTOrderByClause!]` Sort the returned array by one or more fields of it's elements. `where` - `CurrentAlarmRTWhereClause` Filter the data by using a (nested) boolean expression.
`currentStates` - `[CurrentStateRT!]`
Arguments `distinct_on` - `[CurrentStateRTField!]` Return a distinct set of entities, defined by the given fields. `limit` - `Int` Limits the number of objects returned. `offset` - `Int` Start a the specified, zero-based array index. This is only useful in combination with `order_by`. `order_by` - `[CurrentStateRTOrderByClause!]` Sort the returned array by one or more fields of it's elements. `where` - `CurrentStateRTWhereClause` Filter the data by using a (nested) boolean expression.
`decommissionedAt` - `timestamptz`
`latestPositions` - `[LatestPositionRT!]`
Arguments `distinct_on` - `[LatestPositionRTField!]` Return a distinct set of entities, defined by the given fields. `limit` - `Int` Limits the number of objects returned. `offset` - `Int` Start a the specified, zero-based array index. This is only useful in combination with `order_by`. `order_by` - `[LatestPositionRTOrderByClause!]` Sort the returned array by one or more fields of it's elements. `where` - `LatestPositionRTWhereClause` Filter the data by using a (nested) boolean expression.
`latestQuantities` - `[LatestQuantityRT!]`
Arguments `distinct_on` - `[LatestQuantityRTField!]` Return a distinct set of entities, defined by the given fields. `limit` - `Int` Limits the number of objects returned. `offset` - `Int` Start a the specified, zero-based array index. This is only useful in combination with `order_by`. `where` - `LatestQuantityRTWhereClause` Filter the data by using a (nested) boolean expression.
`machineRef` - `Int`	A unique, numeric identifier for the machine.
`make` - `String`
`metrics` - `[MetricRT!]!`
Arguments `distinct_on` - `[MetricRTField!]` Return a distinct set of entities, defined by the given fields. `limit` - `Int` Limits the number of objects returned. `offset` - `Int` Start a the specified, zero-based array index. This is only useful in combination with `order_by`. `order_by` - `[MetricRTOrderByClause!]` Sort the returned array by one or more fields of it's elements. `where` - `MetricRTWhereClause` Filter the data by using a (nested) boolean expression.
`model` - `String`
`name` - `String`	A descriptive, human-readable name
`operatorRuns` - `[OperatorRunTP!]!`
Arguments `distinct_on` - `[OperatorRunTPField!]` Return a distinct set of entities, defined by the given fields. `limit` - `Int` Limits the number of objects returned. `offset` - `Int` Start a the specified, zero-based array index. This is only useful in combination with `order_by`. `order_by` - `[OperatorRunTPOrderByClause!]` Sort the returned array by one or more fields of it's elements. `where` - `OperatorRunTPWhereClause` Filter the data by using a (nested) boolean expression.
`partCountCorrections` - `[PartCountCorrection!]!`
Arguments `distinct_on` - `[PartCountCorrectionField!]` Return a distinct set of entities, defined by the given fields. `limit` - `Int` Limits the number of objects returned. `offset` - `Int` Start a the specified, zero-based array index. This is only useful in combination with `order_by`. `order_by` - `[PartCountCorrectionOrderByClause!]` Sort the returned array by one or more fields of it's elements. `where` - `PartCountCorrectionWhereClause` Filter the data by using a (nested) boolean expression.
`rejects` - `[Reject!]!`
Arguments `distinct_on` - `[RejectField!]` Return a distinct set of entities, defined by the given fields. `limit` - `Int` Limits the number of objects returned. `offset` - `Int` Start a the specified, zero-based array index. This is only useful in combination with `order_by`. `order_by` - `[RejectOrderByClause!]` Sort the returned array by one or more fields of it's elements. `where` - `RejectWhereClause` Filter the data by using a (nested) boolean expression.

Example

{
  "activitySets": [ActivitySet],
  "annotations": [AnnotationTP],
  "company": {
    "companyId": "01c08a38-f33d-4348-9918-e6957cab5c27",
    "name": "Cyberdyne"
  },
  "currentAlarms": [CurrentAlarmRT],
  "currentStates": [CurrentStateRT],
  "decommissionedAt": "2022-05-07T01:08:03.420Z",
  "latestPositions": [LatestPositionRT],
  "latestQuantities": [LatestQuantityRT],
  "machineRef": 123,
  "make": "Citizen",
  "metrics": [MetricRT],
  "model": "K16E",
  "name": "Citizen B12",
  "operatorRuns": [OperatorRunTP],
  "partCountCorrections": [PartCountCorrection],
  "rejects": [Reject]
}

Types

MachineTPField

Values

Enum Value	Description
`decommissionedAt`
`machineRef`	A unique, numeric identifier for the machine.
`make`
`model`
`name`	A descriptive, human-readable name

Example

"decommissionedAt"

Types

MachineTPOrderByClause

Fields

Input Field	Description
`annotations_aggregate` - `AnnotationTP_aggregateOrderByClause`
`company` - `CompanyTPOrderByClause`
`currentAlarms_aggregate` - `CurrentAlarmRT_aggregateOrderByClause`
`currentStates_aggregate` - `CurrentStateRT_aggregateOrderByClause`
`decommissionedAt` - `order_by`
`latestPositions_aggregate` - `LatestPositionRT_aggregateOrderByClause`
`latestQuantities_aggregate` - `LatestQuantityRT_aggregateOrderByClause`
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`make` - `order_by`
`model` - `order_by`
`name` - `order_by`	A descriptive, human-readable name

Example

{
  "annotations_aggregate": AnnotationTP_aggregateOrderByClause,
  "company": CompanyTPOrderByClause,
  "currentAlarms_aggregate": CurrentAlarmRT_aggregateOrderByClause,
  "currentStates_aggregate": CurrentStateRT_aggregateOrderByClause,
  "decommissionedAt": "asc",
  "latestPositions_aggregate": LatestPositionRT_aggregateOrderByClause,
  "latestQuantities_aggregate": LatestQuantityRT_aggregateOrderByClause,
  "machineRef": "asc",
  "make": "asc",
  "model": "asc",
  "name": "asc"
}

Types

MachineTPWhereClause

Fields

Input Field	Description
`_and` - `[MachineTPWhereClause!]`	Combines the given expressions using a logical AND
`_not` - `MachineTPWhereClause`	Negates the result of the given expression.
`_or` - `[MachineTPWhereClause!]`	Combines the given expressions using a logical OR.
`activitySets` - `ActivitySetWhereClause`
`annotations` - `AnnotationTPWhereClause`
`company` - `CompanyTPWhereClause`
`currentAlarms` - `CurrentAlarmRTWhereClause`
`currentStates` - `CurrentStateRTWhereClause`
`decommissionedAt` - `timestamptzComparison`
`latestPositions` - `LatestPositionRTWhereClause`
`latestQuantities` - `LatestQuantityRTWhereClause`
`machineRef` - `IntComparison`	A unique, numeric identifier for the machine.
`make` - `StringComparison`
`metrics` - `MetricRTWhereClause`
`model` - `StringComparison`
`name` - `StringComparison`	A descriptive, human-readable name
`operatorRuns` - `OperatorRunTPWhereClause`
`partCountCorrections` - `PartCountCorrectionWhereClause`
`rejects` - `RejectWhereClause`

Example

{
  "_and": [MachineTPWhereClause],
  "_not": MachineTPWhereClause,
  "_or": [MachineTPWhereClause],
  "activitySets": ActivitySetWhereClause,
  "annotations": AnnotationTPWhereClause,
  "company": CompanyTPWhereClause,
  "currentAlarms": CurrentAlarmRTWhereClause,
  "currentStates": CurrentStateRTWhereClause,
  "decommissionedAt": timestamptzComparison,
  "latestPositions": LatestPositionRTWhereClause,
  "latestQuantities": LatestQuantityRTWhereClause,
  "machineRef": IntComparison,
  "make": StringComparison,
  "metrics": MetricRTWhereClause,
  "model": StringComparison,
  "name": StringComparison,
  "operatorRuns": OperatorRunTPWhereClause,
  "partCountCorrections": PartCountCorrectionWhereClause,
  "rejects": RejectWhereClause
}

Types

MetricRT

Fields

Field Name	Description
`machine` - `MachineTP`	The machine the event originates from.
`machineRef` - `Int`	A unique, numeric identifier for the machine.
`metricKey` - `String`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`subtype` - `String`	The `type` of a metric as defined in the data mapping section of the machine's edit form. See the data catalog for more information.
`type` - `String`	The `type` of a metric as defined in the data mapping section of the machine's edit form. See the data catalog for more information.

Example

{
  "machine": MachineTP,
  "machineRef": 123,
  "metricKey": "abc123",
  "subtype": "abc123",
  "type": "xyz789"
}

Types

MetricRTField

Values

Enum Value	Description
`machineRef`	A unique, numeric identifier for the machine.
`metricKey`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`subtype`	The `type` of a metric as defined in the data mapping section of the machine's edit form. See the data catalog for more information.
`type`	The `type` of a metric as defined in the data mapping section of the machine's edit form. See the data catalog for more information.

Example

"machineRef"

Types

MetricRTOrderByClause

Fields

Input Field	Description
`machine` - `MachineTPOrderByClause`	The machine the event originates from.
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`metricKey` - `order_by`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`subtype` - `order_by`	The `type` of a metric as defined in the data mapping section of the machine's edit form. See the data catalog for more information.
`type` - `order_by`	The `type` of a metric as defined in the data mapping section of the machine's edit form. See the data catalog for more information.

Example

{
  "machine": MachineTPOrderByClause,
  "machineRef": "asc",
  "metricKey": "asc",
  "subtype": "asc",
  "type": "asc"
}

Types

MetricRTWhereClause

Fields

Input Field	Description
`_and` - `[MetricRTWhereClause!]`	Combines the given expressions using a logical AND
`_not` - `MetricRTWhereClause`	Negates the result of the given expression.
`_or` - `[MetricRTWhereClause!]`	Combines the given expressions using a logical OR.
`machine` - `MachineTPWhereClause`	The machine the event originates from.
`machineRef` - `IntComparison`	A unique, numeric identifier for the machine.
`metricKey` - `StringComparison`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`subtype` - `StringComparison`	The `type` of a metric as defined in the data mapping section of the machine's edit form. See the data catalog for more information.
`type` - `StringComparison`	The `type` of a metric as defined in the data mapping section of the machine's edit form. See the data catalog for more information.

Example

{
  "_and": [MetricRTWhereClause],
  "_not": MetricRTWhereClause,
  "_or": [MetricRTWhereClause],
  "machine": MachineTPWhereClause,
  "machineRef": IntComparison,
  "metricKey": StringComparison,
  "subtype": StringComparison,
  "type": StringComparison
}

Types

Operation

Description

Production standards are applied from the Operation selected when starting the first Activity in an Activity Set. This snapshot will not change when standards in the Job Template are updated so an accurate history of the standards as they existed in the moment the work was performed is maintained.

Fields

Field Name	Description
`activitySets` - `[ActivitySet!]!`
Arguments `distinct_on` - `[ActivitySetField!]` Return a distinct set of entities, defined by the given fields. `limit` - `Int` Limits the number of objects returned. `offset` - `Int` Start a the specified, zero-based array index. This is only useful in combination with `order_by`. `order_by` - `[ActivitySetOrderByClause!]` Sort the returned array by one or more fields of it's elements. `where` - `ActivitySetWhereClause` Filter the data by using a (nested) boolean expression.
`company` - `CompanyTP`
`name` - `String`	A descriptive, human-readable name
`operationId` - `String`	A globally unique identifier (UUID) for the operation.

Example

{
  "activitySets": [ActivitySet],
  "company": {"name": "Cyberdynes"},
  "name": "xyz789",
  "operationId": "abc123"
}

Types

OperationField

Values

Enum Value	Description
`name`	A descriptive, human-readable name
`operationId`	A globally unique identifier (UUID) for the operation.

Example

"name"

Types

OperationOrderByClause

Fields

Input Field	Description
`company` - `CompanyTPOrderByClause`
`name` - `order_by`	A descriptive, human-readable name
`operationId` - `order_by`	A globally unique identifier (UUID) for the operation.

Example

{
  "company": CompanyTPOrderByClause,
  "name": "asc",
  "operationId": "asc"
}

Types

OperationWhereClause

Fields

Input Field	Description
`_and` - `[OperationWhereClause!]`	Combines the given expressions using a logical AND
`_not` - `OperationWhereClause`	Negates the result of the given expression.
`_or` - `[OperationWhereClause!]`	Combines the given expressions using a logical OR.
`activitySets` - `ActivitySetWhereClause`
`company` - `CompanyTPWhereClause`
`name` - `StringComparison`	A descriptive, human-readable name
`operationId` - `StringComparison`	A globally unique identifier (UUID) for the operation.

Example

{
  "_and": [OperationWhereClause],
  "_not": OperationWhereClause,
  "_or": [OperationWhereClause],
  "activitySets": ActivitySetWhereClause,
  "company": CompanyTPWhereClause,
  "name": StringComparison,
  "operationId": StringComparison
}

Types

OperatorRunTP

Description

Operator Runs identify periods of time when a particular operator is responsible for a given Machine’s productivity.

Fields

Field Name	Description
`endAt` - `timestamptz`	The end of an interval. Intervals are right-exclusive.
`machine` - `MachineTP`	The machine the event originates from.
`operator` - `OperatorTP`
`operatorRunRef` - `Int`	A unique, numeric identifier for the operatorRun.
`startAt` - `timestamptz`	The start of an interval.

Example

{
  "endAt": "2022-05-07T01:08:03.420Z",
  "machine": MachineTP,
  "operator": OperatorTP,
  "operatorRunRef": 123,
  "startAt": "2022-05-07T01:08:03.420Z"
}

Types

OperatorRunTPField

Values

Enum Value	Description
`endAt`	The end of an interval. Intervals are right-exclusive.
`operatorRunRef`	A unique, numeric identifier for the operatorRun.
`startAt`	The start of an interval.

Example

"endAt"

Types

OperatorRunTPOrderByClause

Fields

Input Field	Description
`endAt` - `order_by`	The end of an interval. Intervals are right-exclusive.
`machine` - `MachineTPOrderByClause`	The machine the event originates from.
`operator` - `OperatorTPOrderByClause`
`operatorRunRef` - `order_by`	A unique, numeric identifier for the operatorRun.
`startAt` - `order_by`	The start of an interval.

Example

{
  "endAt": "asc",
  "machine": MachineTPOrderByClause,
  "operator": OperatorTPOrderByClause,
  "operatorRunRef": "asc",
  "startAt": "asc"
}

Types

OperatorRunTPWhereClause

Fields

Input Field	Description
`_and` - `[OperatorRunTPWhereClause!]`	Combines the given expressions using a logical AND
`_not` - `OperatorRunTPWhereClause`	Negates the result of the given expression.
`_or` - `[OperatorRunTPWhereClause!]`	Combines the given expressions using a logical OR.
`endAt` - `timestamptzComparison`	The end of an interval. Intervals are right-exclusive.
`machine` - `MachineTPWhereClause`	The machine the event originates from.
`operator` - `OperatorTPWhereClause`
`operatorRunRef` - `IntComparison`	A unique, numeric identifier for the operatorRun.
`startAt` - `timestamptzComparison`	The start of an interval.

Example

{
  "_and": [OperatorRunTPWhereClause],
  "_not": OperatorRunTPWhereClause,
  "_or": [OperatorRunTPWhereClause],
  "endAt": timestamptzComparison,
  "machine": MachineTPWhereClause,
  "operator": OperatorTPWhereClause,
  "operatorRunRef": IntComparison,
  "startAt": timestamptzComparison
}

Types

OperatorTP

Fields

Field Name	Description
`company` - `CompanyTP`
`isArchived` - `Boolean`
`name` - `String`	A descriptive, human-readable name
`operatorRef` - `Int`	A unique, numeric identifier for the operator.
`operatorRuns` - `[OperatorRunTP!]!`
Arguments `distinct_on` - `[OperatorRunTPField!]` Return a distinct set of entities, defined by the given fields. `limit` - `Int` Limits the number of objects returned. `offset` - `Int` Start a the specified, zero-based array index. This is only useful in combination with `order_by`. `order_by` - `[OperatorRunTPOrderByClause!]` Sort the returned array by one or more fields of it's elements. `where` - `OperatorRunTPWhereClause` Filter the data by using a (nested) boolean expression.

Example

{
  "company": {"name": "Cyberdynes"},
  "isArchived": true,
  "name": "abc123",
  "operatorRef": 987,
  "operatorRuns": [OperatorRunTP]
}

Types

OperatorTPField

Values

Enum Value	Description
`isArchived`
`name`	A descriptive, human-readable name
`operatorRef`	A unique, numeric identifier for the operator.

Example

"isArchived"

Types

OperatorTPOrderByClause

Fields

Input Field	Description
`company` - `CompanyTPOrderByClause`
`isArchived` - `order_by`
`name` - `order_by`	A descriptive, human-readable name
`operatorRef` - `order_by`	A unique, numeric identifier for the operator.

Example

{
  "company": CompanyTPOrderByClause,
  "isArchived": "asc",
  "name": "asc",
  "operatorRef": "asc"
}

Types

OperatorTPWhereClause

Fields

Input Field	Description
`_and` - `[OperatorTPWhereClause!]`	Combines the given expressions using a logical AND
`_not` - `OperatorTPWhereClause`	Negates the result of the given expression.
`_or` - `[OperatorTPWhereClause!]`	Combines the given expressions using a logical OR.
`company` - `CompanyTPWhereClause`
`isArchived` - `BooleanComparison`
`name` - `StringComparison`	A descriptive, human-readable name
`operatorRef` - `IntComparison`	A unique, numeric identifier for the operator.
`operatorRuns` - `OperatorRunTPWhereClause`

Example

{
  "_and": [OperatorTPWhereClause],
  "_not": OperatorTPWhereClause,
  "_or": [OperatorTPWhereClause],
  "company": CompanyTPWhereClause,
  "isArchived": BooleanComparison,
  "name": StringComparison,
  "operatorRef": IntComparison,
  "operatorRuns": OperatorRunTPWhereClause
}

Types

PartCountCorrection

Description

MachineMetrics identifies when parts are produced by gathering part counter data from the machine. As the part counter increments, the delta represents the number of parts that were produced. There are situations where the behavior of the counter on the machine doesn’t accurately reflect the true number of parts that were produced. Part Count Corrections are used to account for that. The Part Count sum over a given time span should be combined with the Part Count Correction over that same time span to accurately determine the total true parts accounted for.

Fields

Field Name	Description
`effectiveAt` - `timestamptz`
`machine` - `MachineTP`	The machine the event originates from.
`value` - `Int`	The value observed at the `eventTime`.

Example

{
  "effectiveAt": "2022-05-07T01:08:03.420Z",
  "machine": MachineTP,
  "value": 987
}

Types

PartCountCorrectionField

Values

Enum Value	Description
`effectiveAt`
`value`	The value observed at the `eventTime`.

Example

"effectiveAt"

Types

PartCountCorrectionOrderByClause

Fields

Input Field	Description
`effectiveAt` - `order_by`
`machine` - `MachineTPOrderByClause`	The machine the event originates from.
`value` - `order_by`	The value observed at the `eventTime`.

Example

{
  "effectiveAt": "asc",
  "machine": MachineTPOrderByClause,
  "value": "asc"
}

Types

PartCountCorrectionWhereClause

Fields

Input Field	Description
`_and` - `[PartCountCorrectionWhereClause!]`	Combines the given expressions using a logical AND
`_not` - `PartCountCorrectionWhereClause`	Negates the result of the given expression.
`_or` - `[PartCountCorrectionWhereClause!]`	Combines the given expressions using a logical OR.
`effectiveAt` - `timestamptzComparison`
`machine` - `MachineTPWhereClause`	The machine the event originates from.
`value` - `IntComparison`	The value observed at the `eventTime`.

Example

{
  "_and": [PartCountCorrectionWhereClause],
  "_not": PartCountCorrectionWhereClause,
  "_or": [PartCountCorrectionWhereClause],
  "effectiveAt": timestamptzComparison,
  "machine": MachineTPWhereClause,
  "value": IntComparison
}

Types

PartCountRT

Fields

Field Name	Description
`eventTime` - `timestamptz`
`machine` - `MachineTP`	The machine the event originates from.
`machineRef` - `Int`	A unique, numeric identifier for the machine.
`metricKey` - `String`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`sequence` - `Int`	An integer value that determines the order of events with the same `eventTime` and metric.
`value` - `Int`	The value observed at the `eventTime`.

Example

{
  "eventTime": "2022-05-07T01:08:03.420Z",
  "machine": MachineTP,
  "machineRef": 987,
  "metricKey": "abc123",
  "sequence": 987,
  "value": 987
}

Types

PartCountRTField

Values

Enum Value	Description
`eventTime`
`machineRef`	A unique, numeric identifier for the machine.
`metricKey`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`sequence`	An integer value that determines the order of events with the same `eventTime` and metric.
`value`	The value observed at the `eventTime`.

Example

"eventTime"

Types

PartCountRTOrderByClause

Fields

Input Field	Description
`eventTime` - `order_by`
`machine` - `MachineTPOrderByClause`	The machine the event originates from.
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`metricKey` - `order_by`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`sequence` - `order_by`	An integer value that determines the order of events with the same `eventTime` and metric.
`value` - `order_by`	The value observed at the `eventTime`.

Example

{
  "eventTime": "asc",
  "machine": MachineTPOrderByClause,
  "machineRef": "asc",
  "metricKey": "asc",
  "sequence": "asc",
  "value": "asc"
}

Types

PartCountRTWhereClause

Fields

Input Field	Description
`_and` - `[PartCountRTWhereClause!]`	Combines the given expressions using a logical AND
`_not` - `PartCountRTWhereClause`	Negates the result of the given expression.
`_or` - `[PartCountRTWhereClause!]`	Combines the given expressions using a logical OR.
`eventTime` - `timestamptzComparison`
`machine` - `MachineTPWhereClause`	The machine the event originates from.
`machineRef` - `IntComparison`	A unique, numeric identifier for the machine.
`metricKey` - `StringComparison`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`sequence` - `IntComparison`	An integer value that determines the order of events with the same `eventTime` and metric.
`value` - `IntComparison`	The value observed at the `eventTime`.

Example

{
  "_and": [PartCountRTWhereClause],
  "_not": PartCountRTWhereClause,
  "_or": [PartCountRTWhereClause],
  "eventTime": timestamptzComparison,
  "machine": MachineTPWhereClause,
  "machineRef": IntComparison,
  "metricKey": StringComparison,
  "sequence": IntComparison,
  "value": IntComparison
}

Types

PositionRT

Fields

Field Name	Description
`eventTime` - `timestamptz`
`machine` - `MachineTP`	The machine the event originates from.
`machineRef` - `Int`	A unique, numeric identifier for the machine.
`metricKey` - `String`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`x` - `float8`	The x coordinate value.
`y` - `float8`	The y coordinate value.
`z` - `float8`	The z coordinate value.

Example

{
  "eventTime": "2022-05-07T01:08:03.420Z",
  "machine": MachineTP,
  "machineRef": 123,
  "metricKey": "abc123",
  "x": 43.12,
  "y": 43.12,
  "z": 43.12
}

Types

PositionRTField

Values

Enum Value	Description
`eventTime`
`machineRef`	A unique, numeric identifier for the machine.
`metricKey`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`x`	The x coordinate value.
`y`	The y coordinate value.
`z`	The z coordinate value.

Example

"eventTime"

Types

PositionRTOrderByClause

Fields

Input Field	Description
`eventTime` - `order_by`
`machine` - `MachineTPOrderByClause`	The machine the event originates from.
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`metricKey` - `order_by`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`x` - `order_by`	The x coordinate value.
`y` - `order_by`	The y coordinate value.
`z` - `order_by`	The z coordinate value.

Example

{
  "eventTime": "asc",
  "machine": MachineTPOrderByClause,
  "machineRef": "asc",
  "metricKey": "asc",
  "x": "asc",
  "y": "asc",
  "z": "asc"
}

Types

PositionRTWhereClause

Fields

Input Field	Description
`_and` - `[PositionRTWhereClause!]`	Combines the given expressions using a logical AND
`_not` - `PositionRTWhereClause`	Negates the result of the given expression.
`_or` - `[PositionRTWhereClause!]`	Combines the given expressions using a logical OR.
`eventTime` - `timestamptzComparison`
`machine` - `MachineTPWhereClause`	The machine the event originates from.
`machineRef` - `IntComparison`	A unique, numeric identifier for the machine.
`metricKey` - `StringComparison`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`x` - `float8Comparison`	The x coordinate value.
`y` - `float8Comparison`	The y coordinate value.
`z` - `float8Comparison`	The z coordinate value.

Example

{
  "_and": [PositionRTWhereClause],
  "_not": PositionRTWhereClause,
  "_or": [PositionRTWhereClause],
  "eventTime": timestamptzComparison,
  "machine": MachineTPWhereClause,
  "machineRef": IntComparison,
  "metricKey": StringComparison,
  "x": float8Comparison,
  "y": float8Comparison,
  "z": float8Comparison
}

Types

QuantityRT

Fields

Field Name	Description
`eventTime` - `timestamptz`
`machine` - `MachineTP`	The machine the event originates from.
`machineRef` - `Int`	A unique, numeric identifier for the machine.
`metricKey` - `String`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`sequence` - `Int`	An integer value that determines the order of events with the same `eventTime` and metric.
`value` - `float8`	The value observed at the `eventTime`.

Example

{
  "eventTime": "2022-05-07T01:08:03.420Z",
  "machine": MachineTP,
  "machineRef": 123,
  "metricKey": "abc123",
  "sequence": 123,
  "value": 43.12
}

Types

QuantityRTField

Values

Enum Value	Description
`eventTime`
`machineRef`	A unique, numeric identifier for the machine.
`metricKey`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`sequence`	An integer value that determines the order of events with the same `eventTime` and metric.
`value`	The value observed at the `eventTime`.

Example

"eventTime"

Types

QuantityRTOrderByClause

Fields

Input Field	Description
`eventTime` - `order_by`
`machine` - `MachineTPOrderByClause`	The machine the event originates from.
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`metricKey` - `order_by`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`sequence` - `order_by`	An integer value that determines the order of events with the same `eventTime` and metric.
`value` - `order_by`	The value observed at the `eventTime`.

Example

{
  "eventTime": "asc",
  "machine": MachineTPOrderByClause,
  "machineRef": "asc",
  "metricKey": "asc",
  "sequence": "asc",
  "value": "asc"
}

Types

QuantityRTWhereClause

Fields

Input Field	Description
`_and` - `[QuantityRTWhereClause!]`	Combines the given expressions using a logical AND
`_not` - `QuantityRTWhereClause`	Negates the result of the given expression.
`_or` - `[QuantityRTWhereClause!]`	Combines the given expressions using a logical OR.
`eventTime` - `timestamptzComparison`
`machine` - `MachineTPWhereClause`	The machine the event originates from.
`machineRef` - `IntComparison`	A unique, numeric identifier for the machine.
`metricKey` - `StringComparison`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`sequence` - `IntComparison`	An integer value that determines the order of events with the same `eventTime` and metric.
`value` - `float8Comparison`	The value observed at the `eventTime`.

Example

{
  "_and": [QuantityRTWhereClause],
  "_not": QuantityRTWhereClause,
  "_or": [QuantityRTWhereClause],
  "eventTime": timestamptzComparison,
  "machine": MachineTPWhereClause,
  "machineRef": IntComparison,
  "metricKey": StringComparison,
  "sequence": IntComparison,
  "value": float8Comparison
}

Types

Reject

Description

When a part is determined to be defective, it may be Rejected via the Operator Dashboard or through the Quality functionality within MachineMetrics. Rejects come in two types: Scrap and Non-Conform. Further, each Reject is assigned a Reject Reason.

Fields

Field Name	Description
`machine` - `MachineTP`	The machine the event originates from.
`rejectId` - `String`	A globally unique identifier (UUID) for the reject.
`rejectReason` - `RejectReason`
`rejectType` - `String`
`rejectedAt` - `timestamptz`
`value` - `Int`	The value observed at the `eventTime`.

Example

{
  "machine": MachineTP,
  "rejectId": "abc123",
  "rejectReason": RejectReason,
  "rejectType": "xyz789",
  "rejectedAt": "2022-05-07T01:08:03.420Z",
  "value": 123
}

Types

RejectField

Values

Enum Value	Description
`rejectId`	A globally unique identifier (UUID) for the reject.
`rejectType`
`rejectedAt`
`value`	The value observed at the `eventTime`.

Example

"rejectId"

Types

RejectOrderByClause

Fields

Input Field	Description
`machine` - `MachineTPOrderByClause`	The machine the event originates from.
`rejectId` - `order_by`	A globally unique identifier (UUID) for the reject.
`rejectReason` - `RejectReasonOrderByClause`
`rejectType` - `order_by`
`rejectedAt` - `order_by`
`value` - `order_by`	The value observed at the `eventTime`.

Example

{
  "machine": MachineTPOrderByClause,
  "rejectId": "asc",
  "rejectReason": RejectReasonOrderByClause,
  "rejectType": "asc",
  "rejectedAt": "asc",
  "value": "asc"
}

Types

RejectReason

Description

When a part is rejected, the Reject that is created is assigned a specific Reject Reason. While default Reject Reasons are provided, they can be customized to meet the needs of the business.

Fields

Field Name	Description
`color` - `String`
`company` - `CompanyTP`
`isArchived` - `Boolean`
`name` - `String`	A descriptive, human-readable name
`rejectReasonRef` - `Int`	A unique, numeric identifier for the rejectReason.
`rejects` - `[Reject!]!`
Arguments `distinct_on` - `[RejectField!]` Return a distinct set of entities, defined by the given fields. `limit` - `Int` Limits the number of objects returned. `offset` - `Int` Start a the specified, zero-based array index. This is only useful in combination with `order_by`. `order_by` - `[RejectOrderByClause!]` Sort the returned array by one or more fields of it's elements. `where` - `RejectWhereClause` Filter the data by using a (nested) boolean expression.

Example

{
  "color": "abc123",
  "company": {"name": "Cyberdynes"},
  "isArchived": true,
  "name": "xyz789",
  "rejectReasonRef": 123,
  "rejects": [Reject]
}

Types

RejectReasonField

Values

Enum Value	Description
`color`
`isArchived`
`name`	A descriptive, human-readable name
`rejectReasonRef`	A unique, numeric identifier for the rejectReason.

Example

"color"

Types

RejectReasonOrderByClause

Fields

Input Field	Description
`color` - `order_by`
`company` - `CompanyTPOrderByClause`
`isArchived` - `order_by`
`name` - `order_by`	A descriptive, human-readable name
`rejectReasonRef` - `order_by`	A unique, numeric identifier for the rejectReason.

Example

{
  "color": "asc",
  "company": CompanyTPOrderByClause,
  "isArchived": "asc",
  "name": "asc",
  "rejectReasonRef": "asc"
}

Types

RejectReasonWhereClause

Fields

Input Field	Description
`_and` - `[RejectReasonWhereClause!]`	Combines the given expressions using a logical AND
`_not` - `RejectReasonWhereClause`	Negates the result of the given expression.
`_or` - `[RejectReasonWhereClause!]`	Combines the given expressions using a logical OR.
`color` - `StringComparison`
`company` - `CompanyTPWhereClause`
`isArchived` - `BooleanComparison`
`name` - `StringComparison`	A descriptive, human-readable name
`rejectReasonRef` - `IntComparison`	A unique, numeric identifier for the rejectReason.
`rejects` - `RejectWhereClause`

Example

{
  "_and": [RejectReasonWhereClause],
  "_not": RejectReasonWhereClause,
  "_or": [RejectReasonWhereClause],
  "color": StringComparison,
  "company": CompanyTPWhereClause,
  "isArchived": BooleanComparison,
  "name": StringComparison,
  "rejectReasonRef": IntComparison,
  "rejects": RejectWhereClause
}

Types

RejectWhereClause

Fields

Input Field	Description
`_and` - `[RejectWhereClause!]`	Combines the given expressions using a logical AND
`_not` - `RejectWhereClause`	Negates the result of the given expression.
`_or` - `[RejectWhereClause!]`	Combines the given expressions using a logical OR.
`machine` - `MachineTPWhereClause`	The machine the event originates from.
`rejectId` - `StringComparison`	A globally unique identifier (UUID) for the reject.
`rejectReason` - `RejectReasonWhereClause`
`rejectType` - `StringComparison`
`rejectedAt` - `timestamptzComparison`
`value` - `IntComparison`	The value observed at the `eventTime`.

Example

{
  "_and": [RejectWhereClause],
  "_not": RejectWhereClause,
  "_or": [RejectWhereClause],
  "machine": MachineTPWhereClause,
  "rejectId": StringComparison,
  "rejectReason": RejectReasonWhereClause,
  "rejectType": StringComparison,
  "rejectedAt": timestamptzComparison,
  "value": IntComparison
}

Types

StateIntervalRT

Fields

Field Name	Description
`endAt` - `timestamptz`	The end of an interval. Intervals are right-exclusive.
`machine` - `MachineTP`	The machine the event originates from.
`machineRef` - `Int`	A unique, numeric identifier for the machine.
`metric` - `MetricRT`
`metricKey` - `String`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`startAt` - `timestamptz`	The start of an interval.
`value` - `String`	The value observed at the `eventTime`.

Example

{
  "endAt": "2022-05-07T01:08:03.420Z",
  "machine": MachineTP,
  "machineRef": 987,
  "metric": MetricRT,
  "metricKey": "xyz789",
  "startAt": "2022-05-07T01:08:03.420Z",
  "value": "xyz789"
}

Types

StateIntervalRTField

Values

Enum Value	Description
`endAt`	The end of an interval. Intervals are right-exclusive.
`machineRef`	A unique, numeric identifier for the machine.
`metricKey`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`startAt`	The start of an interval.
`value`	The value observed at the `eventTime`.

Example

"endAt"

Types

StateIntervalRTOrderByClause

Fields

Input Field	Description
`endAt` - `order_by`	The end of an interval. Intervals are right-exclusive.
`machine` - `MachineTPOrderByClause`	The machine the event originates from.
`machineRef` - `order_by`	A unique, numeric identifier for the machine.
`metric` - `MetricRTOrderByClause`
`metricKey` - `order_by`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`startAt` - `order_by`	The start of an interval.
`value` - `order_by`	The value observed at the `eventTime`.

Example

{
  "endAt": "asc",
  "machine": MachineTPOrderByClause,
  "machineRef": "asc",
  "metric": MetricRTOrderByClause,
  "metricKey": "asc",
  "startAt": "asc",
  "value": "asc"
}

Types

StateIntervalRTWhereClause

Fields

Input Field	Description
`_and` - `[StateIntervalRTWhereClause!]`	Combines the given expressions using a logical AND
`_not` - `StateIntervalRTWhereClause`	Negates the result of the given expression.
`_or` - `[StateIntervalRTWhereClause!]`	Combines the given expressions using a logical OR.
`endAt` - `timestamptzComparison`	The end of an interval. Intervals are right-exclusive.
`machine` - `MachineTPWhereClause`	The machine the event originates from.
`machineRef` - `IntComparison`	A unique, numeric identifier for the machine.
`metric` - `MetricRTWhereClause`
`metricKey` - `StringComparison`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`startAt` - `timestamptzComparison`	The start of an interval.
`value` - `StringComparison`	The value observed at the `eventTime`.

Example

{
  "_and": [StateIntervalRTWhereClause],
  "_not": StateIntervalRTWhereClause,
  "_or": [StateIntervalRTWhereClause],
  "endAt": timestamptzComparison,
  "machine": MachineTPWhereClause,
  "machineRef": IntComparison,
  "metric": MetricRTWhereClause,
  "metricKey": StringComparison,
  "startAt": timestamptzComparison,
  "value": StringComparison
}

Types

String

Example

"abc123"

Types

StringComparison

Fields

Input Field	Description
`_eq` - `String`	Returns `true` if the event value is equal to the given value; `false` otherwise.
`_gt` - `String`	Returns `true` if the event value is greater than the given value; `false` otherwise.
`_gte` - `String`	Returns `true` if the event value is greater than the given value; `false` otherwise.
`_ilike` - `String`
`_in` - `[String!]`	Returns `true` if the event value is equal to one of the given values in the collection; `false` otherwise.
`_iregex` - `String`
`_is_null` - `Boolean`	Checks whether the event value is or is not `NULL`.
`_like` - `String`
`_lt` - `String`	Returns `true` if the event value is less than the given value; `false` otherwise.
`_lte` - `String`	Returns `true` if the event value is less than the given value; `false` otherwise.
`_neq` - `String`	Returns `true` if the event value is not equal to the given value; `false` otherwise.
`_nilike` - `String`
`_nin` - `[String!]`	Returns `true` if the event value is not equal to any of the given values in the collection; `false` otherwise.
`_niregex` - `String`
`_nlike` - `String`
`_nregex` - `String`
`_nsimilar` - `String`
`_regex` - `String`
`_similar` - `String`

Example

{
  "_eq": "abc123",
  "_gt": "xyz789",
  "_gte": "abc123",
  "_ilike": "xyz789",
  "_in": ["abc123"],
  "_iregex": "abc123",
  "_is_null": true,
  "_like": "xyz789",
  "_lt": "xyz789",
  "_lte": "xyz789",
  "_neq": "xyz789",
  "_nilike": "abc123",
  "_nin": ["abc123"],
  "_niregex": "abc123",
  "_nlike": "abc123",
  "_nregex": "xyz789",
  "_nsimilar": "abc123",
  "_regex": "xyz789",
  "_similar": "abc123"
}

Types

aggregatedPartCountsArgs

Fields

Input Field	Description
`bucketResolution` - `Int`
`bucketWidth` - `interval`
`machineRef` - `Int`	A unique, numeric identifier for the machine.
`metricKey` - `String`	Each metric is globally identified by the combination of `machineRef` and `metricKey`.
`windowEndAt` - `timestamptz`	The end of a time window.
`windowStartAt` - `timestamptz`	The start of a time window.
`windowWidth` - `interval`	The with of a time window. Valid values are for example `1h`, `5m`.

Example

{
  "bucketResolution": 123,
  "bucketWidth": "1h",
  "machineRef": 123,
  "metricKey": "xyz789",
  "windowEndAt": "2022-05-07T01:08:03.420Z",
  "windowStartAt": "2022-05-07T01:08:03.420Z",
  "windowWidth": "1h"
}

Types

aggregatedQuantitiesArgs

Fields

Input Field	Description
`bucketResolution` - `Int`
`bucketWidth` - `interval`
`machineRef` - `Int`	A unique, numeric identifier for the machine.
`metricKey` - `String`</