> For the complete documentation index, see [llms.txt](https://docs.pyck.cloud/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.pyck.cloud/graphql-api/inputs/workflowexecutionswhereinput.md).

# WorkflowExecutionsWhereInput

Audience: Programmer

**Services:** [workflow](https://docs.pyck.cloud/graphql-api/services/workflow.md)

## Fields

| Name                       | Type                                                                                                           | Default | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| -------------------------- | -------------------------------------------------------------------------------------------------------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `not`                      | [WorkflowExecutionsWhereInput](https://docs.pyck.cloud/graphql-api/inputs/workflowexecutionswhereinput.md)     |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `and`                      | \[[WorkflowExecutionsWhereInput](https://docs.pyck.cloud/graphql-api/inputs/workflowexecutionswhereinput.md)!] |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `or`                       | \[[WorkflowExecutionsWhereInput](https://docs.pyck.cloud/graphql-api/inputs/workflowexecutionswhereinput.md)!] |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `typeName`                 | String                                                                                                         |         | type\_name field predicates                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `typeNameNEQ`              | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `typeNameIn`               | \[String!]                                                                                                     |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `typeNameNotIn`            | \[String!]                                                                                                     |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `typeNameContains`         | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `typeNameHasPrefix`        | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `typeNameHasSuffix`        | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `typeNameEqualFold`        | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `typeNameContainsFold`     | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `workflowName`             | String                                                                                                         |         | workflow\_name field predicates                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `workflowNameNEQ`          | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `workflowNameIn`           | \[String!]                                                                                                     |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `workflowNameNotIn`        | \[String!]                                                                                                     |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `workflowNameContains`     | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `workflowNameHasPrefix`    | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `workflowNameHasSuffix`    | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `workflowNameEqualFold`    | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `workflowNameContainsFold` | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `assignee`                 | String                                                                                                         |         | assignee field predicates                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `assigneeNEQ`              | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `assigneeIn`               | \[String!]                                                                                                     |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `assigneeNotIn`            | \[String!]                                                                                                     |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `assigneeIsNil`            | Boolean                                                                                                        |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `assigneeNotNil`           | Boolean                                                                                                        |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `assigneeContains`         | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `assigneeHasPrefix`        | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `assigneeHasSuffix`        | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `assigneeEqualFold`        | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `assigneeContainsFold`     | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `isAssignable`             | Boolean                                                                                                        |         | <p>is\_assignable field predicate. Matches the pyck\_workflow\_is\_assignable<br>Temporal search attribute.<br><br>Absent-attribute semantics (default-true):<br>- <code>isAssignable: true</code> matches workflows with the attribute set to true<br>OR not set at all. Workflows that never opted in (e.g. those not<br>calling workflowsdk.SetupDefaults with WorkflowIsAssignableSetter)<br>are considered assignable by default.<br>- <code>isAssignable: false</code> matches only workflows that explicitly wrote<br>the attribute as false.<br>- omit the field to not filter on assignability at all.</p> |
| `groupBy`                  | String                                                                                                         |         | group\_by field predicates                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `groupByNEQ`               | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `groupByIn`                | \[String!]                                                                                                     |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `groupByNotIn`             | \[String!]                                                                                                     |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `groupByIsNil`             | Boolean                                                                                                        |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `groupByNotNil`            | Boolean                                                                                                        |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `groupByContains`          | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `groupByHasPrefix`         | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `groupByHasSuffix`         | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `groupByEqualFold`         | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `groupByContainsFold`      | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `title`                    | String                                                                                                         |         | <p>title field predicates. Matches the pyck\_title Temporal search attribute,<br>the per-workflow display label.</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| `titleNEQ`                 | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `titleIn`                  | \[String!]                                                                                                     |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `titleNotIn`               | \[String!]                                                                                                     |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `titleIsNil`               | Boolean                                                                                                        |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `titleNotNil`              | Boolean                                                                                                        |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `titleContains`            | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `titleHasPrefix`           | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `titleHasSuffix`           | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `titleEqualFold`           | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `titleContainsFold`        | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `groupTitle`               | String                                                                                                         |         | <p>group\_title field predicates. Matches the pyck\_group\_title Temporal search<br>attribute, the human-readable label for the workflow group header.</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `groupTitleNEQ`            | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `groupTitleIn`             | \[String!]                                                                                                     |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `groupTitleNotIn`          | \[String!]                                                                                                     |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `groupTitleIsNil`          | Boolean                                                                                                        |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `groupTitleNotNil`         | Boolean                                                                                                        |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `groupTitleContains`       | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `groupTitleHasPrefix`      | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `groupTitleHasSuffix`      | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `groupTitleEqualFold`      | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `groupTitleContainsFold`   | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `sortKey`                  | Int                                                                                                            |         | <p>sort\_key field predicates. Matches the pyck\_sort\_key Temporal search<br>attribute, a numeric value used by the UI to impose a stable display order.</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `sortKeyNEQ`               | Int                                                                                                            |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `sortKeyIn`                | \[Int!]                                                                                                        |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `sortKeyNotIn`             | \[Int!]                                                                                                        |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `sortKeyGT`                | Int                                                                                                            |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `sortKeyGTE`               | Int                                                                                                            |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `sortKeyLT`                | Int                                                                                                            |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `sortKeyLTE`               | Int                                                                                                            |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `sortKeyIsNil`             | Boolean                                                                                                        |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `sortKeyNotNil`            | Boolean                                                                                                        |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `workflowID`               | String                                                                                                         |         | workflow\_id field predicates                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `workflowIDNEQ`            | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `workflowIDIn`             | \[String!]                                                                                                     |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `workflowIDNotIn`          | \[String!]                                                                                                     |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `workflowIDContains`       | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `workflowIDHasPrefix`      | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `workflowIDHasSuffix`      | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `workflowIDEqualFold`      | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `workflowIDContainsFold`   | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `runID`                    | String                                                                                                         |         | run\_id field predicates                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `runIDNEQ`                 | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `runIDIn`                  | \[String!]                                                                                                     |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `runIDNotIn`               | \[String!]                                                                                                     |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `runIDContains`            | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `runIDHasPrefix`           | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `runIDHasSuffix`           | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `runIDEqualFold`           | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `runIDContainsFold`        | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `status`                   | String                                                                                                         |         | status field predicates                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `statusNEQ`                | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `statusIn`                 | \[String!]                                                                                                     |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `statusNotIn`              | \[String!]                                                                                                     |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `statusContains`           | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `statusHasPrefix`          | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `statusHasSuffix`          | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `statusEqualFold`          | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `statusContainsFold`       | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `startTime`                | String                                                                                                         |         | start\_time field predicates                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `startTimeNEQ`             | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `startTimeIn`              | \[String!]                                                                                                     |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `startTimeNotIn`           | \[String!]                                                                                                     |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `startTimeGT`              | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `startTimeGTE`             | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `startTimeLT`              | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `startTimeLTE`             | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `closeTime`                | String                                                                                                         |         | close\_time field predicates                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `closeTimeNEQ`             | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `closeTimeIn`              | \[String!]                                                                                                     |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `closeTimeNotIn`           | \[String!]                                                                                                     |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `closeTimeGT`              | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `closeTimeGTE`             | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `closeTimeLT`              | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `closeTimeLTE`             | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `closeTimeIsNil`           | Boolean                                                                                                        |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `closeTimeNotNil`          | Boolean                                                                                                        |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `service`                  | String                                                                                                         |         | service field predicates                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `serviceNEQ`               | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `serviceIn`                | \[String!]                                                                                                     |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `serviceNotIn`             | \[String!]                                                                                                     |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `serviceContains`          | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `serviceHasPrefix`         | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `serviceHasSuffix`         | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `serviceEqualFold`         | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `serviceContainsFold`      | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `serviceIsNil`             | Boolean                                                                                                        |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `serviceNotNil`            | Boolean                                                                                                        |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `dataType`                 | String                                                                                                         |         | dataType field predicates                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `dataTypeNEQ`              | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `dataTypeIn`               | \[String!]                                                                                                     |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `dataTypeNotIn`            | \[String!]                                                                                                     |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `dataTypeContains`         | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `dataTypeHasPrefix`        | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `dataTypeHasSuffix`        | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `dataTypeEqualFold`        | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `dataTypeContainsFold`     | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `dataTypeIsNil`            | Boolean                                                                                                        |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `dataTypeNotNil`           | Boolean                                                                                                        |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `dataId`                   | String                                                                                                         |         | dataId field predicates                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `dataIdNEQ`                | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `dataIdIn`                 | \[String!]                                                                                                     |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `dataIdNotIn`              | \[String!]                                                                                                     |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `dataIdContains`           | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `dataIdHasPrefix`          | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `dataIdHasSuffix`          | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `dataIdEqualFold`          | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `dataIdContainsFold`       | String                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `dataIdIsNil`              | Boolean                                                                                                        |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `dataIdNotNil`             | Boolean                                                                                                        |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `transactionID`            | ID                                                                                                             |         | <p>transactionID field predicates — the handle mutations return. Filtering by<br>it lists the executions that mutation started. An empty result means the<br>workflows are not started or not visible yet (poll again) or the mutation<br>triggered none. Exact match only (the value is a UUID).</p>                                                                                                                                                                                                                                                                                                               |
| `transactionIDNEQ`         | ID                                                                                                             |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `transactionIDIn`          | \[ID!]                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `transactionIDNotIn`       | \[ID!]                                                                                                         |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `targets`                  | \[[WorkflowTarget](https://docs.pyck.cloud/graphql-api/enums/workflowtarget.md)!]                              |         | <p>targets field predicates (KeywordList — matches if the workflow's targets<br>list contains any element of the supplied set; targetsNotIn excludes them).</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `targetsNotIn`             | \[[WorkflowTarget](https://docs.pyck.cloud/graphql-api/enums/workflowtarget.md)!]                              |         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.pyck.cloud/graphql-api/inputs/workflowexecutionswhereinput.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
