All Superinterfaces:

BaseQuery<TaskSummary,TaskQueryColumnName>

All Known Implementing Classes:

TaskQueryImpl
```
public interface TaskQuery
extends BaseQuery<TaskSummary,TaskQueryColumnName>
```
TaskQuery for generating dynamic sql.

Nested Class Summary
- Nested classes/interfaces inherited from interface pro.taskana.common.api.BaseQuery
  BaseQuery.SortDirection

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method	Description
`TaskQuery`	`attachmentChannelIn(String... attachmentChannel)`	Add the values of attachment channel for exact matching to your query.
`TaskQuery`	`attachmentChannelLike(String... attachmentChannel)`	Add the values of attachment channel for pattern matching to your query.
`TaskQuery`	`attachmentChannelNotIn(String... attachmentChannel)`	Exclude the values of attachment channel for exact matching from your query.
`TaskQuery`	`attachmentChannelNotLike(String... attachmentChannel)`	Exclude the values of attachment channel for pattern matching from your query.
`TaskQuery`	`attachmentClassificationIdIn(String... attachmentClassificationId)`	Add the attachment classification Ids for exact matching to your query.
`TaskQuery`	`attachmentClassificationIdNotIn(String... attachmentClassificationId)`	Exclude the attachment classification Ids for exact matching from your query.
`TaskQuery`	`attachmentClassificationKeyIn(String... attachmentClassificationKeys)`	Add the attachment classification keys for exact matching to your query.
`TaskQuery`	`attachmentClassificationKeyLike(String... attachmentClassificationKey)`	Add the attachment classification Keys for pattern matching to your query.
`TaskQuery`	`attachmentClassificationKeyNotIn(String... attachmentClassificationKeys)`	Exclude the attachment classification keys for exact matching from your query.
`TaskQuery`	`attachmentClassificationKeyNotLike(String... attachmentClassificationKey)`	Exclude the attachment classification Keys for pattern matching from your query.
`TaskQuery`	`attachmentClassificationNameIn(String... attachmentClassificationName)`	Add the attachment classification names for exact matching to your query.
`TaskQuery`	`attachmentClassificationNameLike(String... attachmentClassificationName)`	Add the values of attachment classification names for pattern matching to your query.
`TaskQuery`	`attachmentClassificationNameNotIn(String... attachmentClassificationName)`	Exclude the attachment classification names for exact matching from your query.
`TaskQuery`	`attachmentClassificationNameNotLike(String... attachmentClassificationName)`	Exclude the values of attachment classification names for pattern matching from your query.
`TaskQuery`	`attachmentNotReceivedWithin(TimeInterval... receivedNotIn)`	Exclude the received-dates from your query.
`TaskQuery`	`attachmentReceivedWithin(TimeInterval... receivedIn)`	Add your received-dates to your query.
`TaskQuery`	`attachmentReferenceValueIn(String... referenceValue)`	Add the values of reference values for exact matching to your query.
`TaskQuery`	`attachmentReferenceValueLike(String... referenceValue)`	Add the values of reference values for pattern matching to your query.
`TaskQuery`	`attachmentReferenceValueNotIn(String... referenceValue)`	Exclude the values of reference values for exact matching from your query.
`TaskQuery`	`attachmentReferenceValueNotLike(String... referenceValue)`	Exclude the values of reference values for pattern matching to your query.
`TaskQuery`	`businessProcessIdIn(String... businessProcessIds)`	Add the business process ids for exact matching to your query.
`TaskQuery`	`businessProcessIdLike(String... businessProcessIds)`	Add your businessProcessId for pattern matching to your query.
`TaskQuery`	`businessProcessIdNotIn(String... businessProcessIds)`	Exclude the business process ids for exact matching from your query.
`TaskQuery`	`businessProcessIdNotLike(String... businessProcessIds)`	Exclude your businessProcessId for pattern matching to your query.
`TaskQuery`	`callbackStateIn(CallbackState... states)`	Add your callbackState to your query.
`TaskQuery`	`callbackStateNotIn(CallbackState... states)`	Exclude the callbackState from your query.
`TaskQuery`	`claimedNotWithin(TimeInterval... intervals)`	Exclude the time intervals within which the task wasn't claimed from your query.
`TaskQuery`	`claimedWithin(TimeInterval... intervals)`	Add the time intervals within which the task was claimed to your query.
`TaskQuery`	`classificationCategoryIn(String... classificationCategories)`	Add your classificationCategory to your query.
`TaskQuery`	`classificationCategoryLike(String... classificationCategories)`	Add your classificationCategory for pattern matching to your query.
`TaskQuery`	`classificationCategoryNotIn(String... classificationCategories)`	Exclude the classificationCategory from your query.
`TaskQuery`	`classificationCategoryNotLike(String... classificationCategories)`	Exclude the classificationCategory for pattern matching from your query.
`TaskQuery`	`classificationIdIn(String... classificationIds)`	Add your classificationId to your query.
`TaskQuery`	`classificationIdNotIn(String... classificationIds)`	Exclude these classificationIds from your query.
`TaskQuery`	`classificationKeyIn(String... classificationKeys)`	Add your classificationKey to your query.
`TaskQuery`	`classificationKeyLike(String... classificationKeys)`	Add your classificationKey for pattern matching to your query.
`TaskQuery`	`classificationKeyNotIn(String... classificationKeys)`	Exclude these classificationKeys from your query.
`TaskQuery`	`classificationKeyNotLike(String... classificationKeys)`	Exclude the classificationKeys for pattern matching from your query.
`TaskQuery`	`classificationNameIn(String... classificationNames)`	Add your classificationName to your query.
`TaskQuery`	`classificationNameLike(String... classificationNames)`	Add your classificationName for pattern matching to your query.
`TaskQuery`	`classificationNameNotIn(String... classificationNames)`	Exclude the classificationName from your query.
`TaskQuery`	`classificationNameNotLike(String... classificationNames)`	Exclude the classificationName for pattern matching from your query.
`TaskQuery`	`completedNotWithin(TimeInterval... intervals)`	Exclude the time intervals within which the task wasn't completed from your query.
`TaskQuery`	`completedWithin(TimeInterval... intervals)`	Add the time intervals within which the task was completed to your query.
`TaskQuery`	`createdNotWithin(TimeInterval... intervals)`	Exclude the time intervals within which the task wasn't created from your query.
`TaskQuery`	`createdWithin(TimeInterval... intervals)`	Add the time intervals within which the task was created to your query.
`ObjectReferenceQuery`	`createObjectReferenceQuery()`	This method provides a query builder for quering the database.
`TaskQuery`	`creatorIn(String... creators)`	Add the UserIds of the creator to your query.
`TaskQuery`	`creatorLike(String... creators)`	Add the UserIds of the creator for pattern matching to your query.
`TaskQuery`	`creatorNotIn(String... creators)`	Exclude the UserIds of the creator from your query.
`TaskQuery`	`creatorNotLike(String... creators)`	Exclude the UserIds of the creator for pattern matching from your query.
`TaskQuery`	`customAttributeIn(TaskCustomField customField, String... searchArguments)`	Add the values of custom attributes for exact matching to your query.
`TaskQuery`	`customAttributeLike(TaskCustomField customField, String... searchArguments)`	Add the values of custom attributes for pattern matching to your query.
`TaskQuery`	`customAttributeNotIn(TaskCustomField customField, String... searchArguments)`	Exclude these values of custom attributes from your query.
`TaskQuery`	`customAttributeNotLike(TaskCustomField customField, String... searchArguments)`	Exclude the values of custom attributes for pattern matching from your query.
`TaskQuery`	`descriptionLike(String... description)`	Add your description for pattern matching to your query.
`TaskQuery`	`descriptionNotLike(String... description)`	Exclude your description for pattern matching from your query.
`TaskQuery`	`dueNotWithin(TimeInterval... intervals)`	Exclude the time intervals within which the task isn't due from your query.
`TaskQuery`	`dueWithin(TimeInterval... intervals)`	Add the time intervals within which the task is due to your query.
`TaskQuery`	`externalIdIn(String... externalIds)`	Add your external ids to your query.
`TaskQuery`	`externalIdNotIn(String... externalIds)`	Exclude these external ids from your query.
`TaskQuery`	`idIn(String... taskIds)`	Filter for summaries which contain one of the given taskIds.
`TaskQuery`	`idNotIn(String... taskIds)`	Exclude summaries which contain one of the given taskIds.
`TaskQuery`	`modifiedNotWithin(TimeInterval... intervals)`	Exclude the time intervals within which the task wasn't modified from your query.
`TaskQuery`	`modifiedWithin(TimeInterval... intervals)`	Add the time intervals within which the task wasn't modified to your query.
`TaskQuery`	`nameIn(String... names)`	Add your names to your query.
`TaskQuery`	`nameLike(String... names)`	Add your name for pattern matching to your query.
`TaskQuery`	`nameNotIn(String... names)`	Exclude these names from your query.
`TaskQuery`	`nameNotLike(String... names)`	Exclude these names for pattern matching from your query.
`TaskQuery`	`noteLike(String... note)`	Add your custom note for pattern matching to your query.
`TaskQuery`	`noteNotLike(String... note)`	Exclude your custom note for pattern matching from your query.
`TaskQuery`	`orderByAttachmentChannel(BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to the attachment channel.
`TaskQuery`	`orderByAttachmentClassificationId(BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to the attachment classification id.
`TaskQuery`	`orderByAttachmentClassificationKey(BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to the attachment classification key.
`TaskQuery`	`orderByAttachmentClassificationName(BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to the attachment classification name.
`TaskQuery`	`orderByAttachmentReceived(BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to the attachment received.
`TaskQuery`	`orderByAttachmentReference(BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to the attachment reference value.
`TaskQuery`	`orderByBusinessProcessId(BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to the business process id.
`TaskQuery`	`orderByClaimed(BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to the claimed timestamp.
`TaskQuery`	`orderByClassificationKey(BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to the classification key.
`TaskQuery`	`orderByClassificationName(BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to the classification name.
`TaskQuery`	`orderByCompleted(BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to the completed timestamp.
`TaskQuery`	`orderByCreated(BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to the created timestamp.
`TaskQuery`	`orderByCreator(BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to creators name.
`TaskQuery`	`orderByCustomAttribute(TaskCustomField customField, BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to the value of a custom field.
`TaskQuery`	`orderByDomain(BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to the domain.
`TaskQuery`	`orderByDue(BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to the due timestamp.
`TaskQuery`	`orderByModified(BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to the modified timestamp.
`TaskQuery`	`orderByName(BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to name.
`TaskQuery`	`orderByNote(BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to the note.
`TaskQuery`	`orderByOwner(BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to the owner.
`TaskQuery`	`orderByOwnerLongName(BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to the owner's long name.
`TaskQuery`	`orderByParentBusinessProcessId(BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to the parent business process id.
`TaskQuery`	`orderByPlanned(BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to the planned timestamp.
`TaskQuery`	`orderByPrimaryObjectReferenceCompany(BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to the company of the primary object reference.
`TaskQuery`	`orderByPrimaryObjectReferenceSystem(BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to the system of the primary object reference.
`TaskQuery`	`orderByPrimaryObjectReferenceSystemInstance(BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to the system instance of the primary object reference.
`TaskQuery`	`orderByPrimaryObjectReferenceType(BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to the type of the primary object reference.
`TaskQuery`	`orderByPrimaryObjectReferenceValue(BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to the value of the primary object reference.
`TaskQuery`	`orderByPriority(BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to the priority.
`TaskQuery`	`orderByReceived(BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to the received timestamp.
`TaskQuery`	`orderByState(BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to the state.
`TaskQuery`	`orderByTaskId(BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to the primary task id.
`TaskQuery`	`orderByWorkbasketId(BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to the workbasket-Id of the tasks.
`TaskQuery`	`orderByWorkbasketKey(BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to the workbasket key.
`TaskQuery`	`orderByWorkbasketName(BaseQuery.SortDirection sortDirection)`	This method sorts the query result according to the workbasket name of the tasks.
`TaskQuery`	`ownerIn(String... owners)`	Add the owners to your query.
`TaskQuery`	`ownerLike(String... owners)`	Add the owner for pattern matching to your query.
`TaskQuery`	`ownerLongNameIn(String... longNames)`	Adds the long names of the owners to your query.
`TaskQuery`	`ownerLongNameLike(String... longNames)`	Adds the long names of the owner for pattern matching to your query.
`TaskQuery`	`ownerLongNameNotIn(String... longNames)`	Adds the long names of the owners to your query, which should not be contained.
`TaskQuery`	`ownerLongNameNotLike(String... longNames)`	Adds the long names of the owner for pattern matching to your query, which should not be contained.
`TaskQuery`	`ownerNotIn(String... owners)`	Filter out owners.
`TaskQuery`	`ownerNotLike(String... owners)`	Exclude the owner for pattern matching from your query.
`TaskQuery`	`parentBusinessProcessIdIn(String... parentBusinessProcessIds)`	Add the parent business process ids for exact matching to your query.
`TaskQuery`	`parentBusinessProcessIdLike(String... businessProcessIds)`	Add your parent business process id for pattern matching to your query.
`TaskQuery`	`parentBusinessProcessIdNotIn(String... parentBusinessProcessIds)`	Exclude the parent business process ids for exact matching from your query.
`TaskQuery`	`parentBusinessProcessIdNotLike(String... businessProcessIds)`	Exclude your parent business process id for pattern matching to your query.
`TaskQuery`	`plannedNotWithin(TimeInterval... intervals)`	Exclude the time intervals within which the task isn't planned from your query.
`TaskQuery`	`plannedWithin(TimeInterval... intervals)`	Add the time intervals within which the task is planned to your query.
`TaskQuery`	`primaryObjectReferenceCompanyIn(String... companies)`	Add the companies of the primary object reference for exact matching to your query.
`TaskQuery`	`primaryObjectReferenceCompanyLike(String... company)`	Add the company of the primary object reference for pattern matching to your query.
`TaskQuery`	`primaryObjectReferenceCompanyNotIn(String... companies)`	Exclude the companies of the primary object reference for exact matching from your query.
`TaskQuery`	`primaryObjectReferenceCompanyNotLike(String... company)`	Exclude the company of the primary object reference for pattern matching from your query.
`TaskQuery`	`primaryObjectReferenceIn(ObjectReference... objectReferences)`	Add the ObjectReference to exact match to your query.
`TaskQuery`	`primaryObjectReferenceSystemIn(String... systems)`	Add the systems of the primary object reference for exact matching to your query.
`TaskQuery`	`primaryObjectReferenceSystemInstanceIn(String... systemInstances)`	Add the system instances of the primary object reference for exact matching to your query.
`TaskQuery`	`primaryObjectReferenceSystemInstanceLike(String... systemInstances)`	Add the system instance of the primary object reference for pattern matching to your query.
`TaskQuery`	`primaryObjectReferenceSystemInstanceNotIn(String... systemInstances)`	Exclude the system instances of the primary object reference for exact matching from your query.
`TaskQuery`	`primaryObjectReferenceSystemInstanceNotLike(String... systemInstances)`	Exclude the system instance of the primary object reference for pattern matching from your query.
`TaskQuery`	`primaryObjectReferenceSystemLike(String... systems)`	Add the system of the primary object reference for pattern matching to your query.
`TaskQuery`	`primaryObjectReferenceSystemNotIn(String... systems)`	Exclude the systems of the primary object reference for exact matching from your query.
`TaskQuery`	`primaryObjectReferenceSystemNotLike(String... systems)`	Exclude the system of the primary object reference for pattern matching from your query.
`TaskQuery`	`primaryObjectReferenceTypeIn(String... types)`	Add the types of the primary object reference for exact matching to your query.
`TaskQuery`	`primaryObjectReferenceTypeLike(String... types)`	Add the type of the primary object reference for pattern matching to your query.
`TaskQuery`	`primaryObjectReferenceTypeNotIn(String... types)`	Exclude the types of the primary object reference for exact matching from your query.
`TaskQuery`	`primaryObjectReferenceTypeNotLike(String... types)`	Exclude the type of the primary object reference for pattern matching from your query.
`TaskQuery`	`primaryObjectReferenceValueIn(String... values)`	Add the values of the primary object reference for exact matching to your query.
`TaskQuery`	`primaryObjectReferenceValueLike(String... values)`	Add the value of the primary object reference for pattern matching to your query.
`TaskQuery`	`primaryObjectReferenceValueNotIn(String... values)`	Exclude the values of the primary object reference for exact matching from your query.
`TaskQuery`	`primaryObjectReferenceValueNotLike(String... values)`	Exclude the value of the primary object reference for pattern matching from your query.
`TaskQuery`	`priorityIn(int... priorities)`	Add your priorities to your query.
`TaskQuery`	`priorityNotIn(int... priorities)`	Exclude the priorities from your query.
`TaskQuery`	`readEquals(Boolean isRead)`	Add the isRead flag to the query.
`TaskQuery`	`receivedNotWithin(TimeInterval... intervals)`	Exclude the time intervals within which the task wasn't received from your query.
`TaskQuery`	`receivedWithin(TimeInterval... intervals)`	Add the time intervals within which the task is received to your query.
`TaskQuery`	`secondaryObjectReferenceIn(ObjectReference... objectReferences)`	Add the `ObjectReference` to exact match to your query.
`TaskQuery`	`sorCompanyIn(String... companyIn)`	Add the values of the company of at least one of the secondaryObjectReferences for exact matching to your query.
`TaskQuery`	`sorCompanyLike(String... companyLike)`	Add the values of company of at least one of the secondaryobjectReferences for pattern matching to your query.
`TaskQuery`	`sorSystemIn(String... systemIn)`	Add the values of the system of at least one of the secondaryObjectReferences for exact matching to your query.
`TaskQuery`	`sorSystemInstanceIn(String... systemInstanceIn)`	Add the values of the systemInstance of at least one of the secondaryObjectReferences for exact matching to your query.
`TaskQuery`	`sorSystemInstanceLike(String... systemInstanceLike)`	Add the values of systemInstance of at least one of the secondaryobjectReferences for pattern matching to your query.
`TaskQuery`	`sorSystemLike(String... systemLike)`	Add the values of system of at least one of the secondaryobjectReferences for pattern matching to your query.
`TaskQuery`	`sorTypeIn(String... typeIn)`	Add the values of the type of at least one of the secondaryObjectReferences for exact matching to your query.
`TaskQuery`	`sorTypeLike(String... typeLike)`	Add the values of type of at least one of the secondaryobjectReferences for pattern matching to your query.
`TaskQuery`	`sorValueIn(String... valueIn)`	Add the values of the value of at least one of the secondaryObjectReferences for exact matching to your query.
`TaskQuery`	`sorValueLike(String... valueLike)`	Add the values of value of at least one of the secondaryobjectReferences for pattern matching to your query.
`TaskQuery`	`stateIn(TaskState... states)`	Add your state to your query.
`TaskQuery`	`stateNotIn(TaskState... states)`	Exclude these states from your query.
`TaskQuery`	`transferredEquals(Boolean isTransferred)`	Add the isTransferred flag to the query.
`TaskQuery`	`wildcardSearchFieldsIn(WildcardSearchField... wildcardSearchFields)`	Add the Task fields for which the wildcard search should be performed as an exact match to your query.
`TaskQuery`	`wildcardSearchValueLike(String wildcardSearchValue)`	Add your wildcard search value for pattern matching to your query.
`TaskQuery`	`withoutAttachment()`	This method adds the condition that only Tasks that don't have any Attachments will be included in the TaskQuery.
`TaskQuery`	`workbasketIdIn(String... workbasketIds)`	Add your workbasket id to the query.
`TaskQuery`	`workbasketIdNotIn(String... workbasketIds)`	Exclude the workbasket id from the query.
`TaskQuery`	`workbasketKeyDomainIn(KeyDomain... workbasketIdentifiers)`	Add your workbasket key to the query.
`TaskQuery`	`workbasketKeyDomainNotIn(KeyDomain... workbasketIdentifiers)`	Exclude the workbasket key from the query.

Methods inherited from interface pro.taskana.common.api.BaseQuery
count, list, list, listPage, listValues, single, toLowerCopy

- Method Detail
  - idIn
```
TaskQuery idIn(String... taskIds)
```
    Filter for summaries which contain one of the given taskIds.
    
    Parameters:
    
    taskIds - The ids of the searched-for tasks.
    
    Returns:
    
    the taskQuery
  - idNotIn
```
TaskQuery idNotIn(String... taskIds)
```
    Exclude summaries which contain one of the given taskIds.
    
    Parameters:
    
    taskIds - The ids of the searched-for tasks.
    
    Returns:
    
    the taskQuery
  - orderByTaskId
```
TaskQuery orderByTaskId(BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to the primary task id.
    
    Parameters:
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query
  - externalIdIn
```
TaskQuery externalIdIn(String... externalIds)
```
    Add your external ids to your query.
    
    Parameters:
    
    externalIds - the external ids as Strings
    
    Returns:
    
    the query
  - externalIdNotIn
```
TaskQuery externalIdNotIn(String... externalIds)
```
    Exclude these external ids from your query.
    
    Parameters:
    
    externalIds - the external ids as Strings
    
    Returns:
    
    the query
  - receivedWithin
```
TaskQuery receivedWithin(TimeInterval... intervals)
```
    Add the time intervals within which the task is received to your query. For each time interval, the database query will search for tasks whose received timestamp is before the interval's begin and after the interval's end. If more than one interval is specified, the query will connect them with the OR keyword. If either begin or end of an interval are null, these values will not be specified in the query.
    
    Parameters:
    
    intervals - - the TimeIntervals within which the task is received
    
    Returns:
    
    the query
  - receivedNotWithin
```
TaskQuery receivedNotWithin(TimeInterval... intervals)
```
    Exclude the time intervals within which the task wasn't received from your query. For each time interval, the database query will search for tasks whose received timestamp is before the interval's begin and after the interval's end. If more than one interval is specified, the query will connect them with the OR keyword. If either begin or end of an interval are null, these values will not be specified in the query.
    
    Parameters:
    
    intervals - - the TimeIntervals within which the task wasn't received
    
    Returns:
    
    the query
  - orderByReceived
```
TaskQuery orderByReceived(BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to the received timestamp.
    
    Parameters:
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query
  - createdWithin
```
TaskQuery createdWithin(TimeInterval... intervals)
```
    Add the time intervals within which the task was created to your query. For each time interval, the database query will search for tasks whose created timestamp is after or at the interval's begin and before or at the interval's end. If more than one interval is specified, the query will connect them with the OR keyword. If either begin or end of an interval are null, these values will not be specified in the query.
    
    Parameters:
    
    intervals - - the TimeIntervals within which the task was created
    
    Returns:
    
    the query
  - createdNotWithin
```
TaskQuery createdNotWithin(TimeInterval... intervals)
```
    Exclude the time intervals within which the task wasn't created from your query. For each time interval, the database query will search for tasks whose created timestamp is before the interval's begin and after the interval's end. If more than one interval is specified, the query will connect them with the OR keyword. If either begin or end of an interval are null, these values will not be specified in the query.
    
    Parameters:
    
    intervals - - the TimeIntervals within which the task wasn't created
    
    Returns:
    
    the query
  - orderByCreated
```
TaskQuery orderByCreated(BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to the created timestamp.
    
    Parameters:
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query
  - claimedWithin
```
TaskQuery claimedWithin(TimeInterval... intervals)
```
    Add the time intervals within which the task was claimed to your query. For each time interval, the database query will search for tasks whose claimed timestamp is after or at the interval's begin and before or at the interval's end. If more than one interval is specified, the query will connect them with the OR keyword. If either begin or end of an interval are null, these values will not be specified in the query.
    
    Parameters:
    
    intervals - - the TimeIntervals within which the task was claimed
    
    Returns:
    
    the query
  - claimedNotWithin
```
TaskQuery claimedNotWithin(TimeInterval... intervals)
```
    Exclude the time intervals within which the task wasn't claimed from your query. For each time interval, the database query will search for tasks whose claimed timestamp is before the interval's begin and after the interval's end. If more than one interval is specified, the query will connect them with the OR keyword. If either begin or end of an interval are null, these values will not be specified in the query.
    
    Parameters:
    
    intervals - - the TimeIntervals within which the task wasn't claimed
    
    Returns:
    
    the query
  - orderByClaimed
```
TaskQuery orderByClaimed(BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to the claimed timestamp.
    
    Parameters:
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query
  - modifiedWithin
```
TaskQuery modifiedWithin(TimeInterval... intervals)
```
    Add the time intervals within which the task wasn't modified to your query. For each time interval, the database query will search for tasks whose modified timestamp is after or at the interval's begin and before or at the interval's end. If more than one interval is specified, the query will connect them with the OR keyword. If either begin or end of an interval are null, these values will not be specified in the query.
    
    Parameters:
    
    intervals - - the TimeIntervals within which the task was modified
    
    Returns:
    
    the query
  - modifiedNotWithin
```
TaskQuery modifiedNotWithin(TimeInterval... intervals)
```
    Exclude the time intervals within which the task wasn't modified from your query. For each time interval, the database query will search for tasks whose modified timestamp is before the interval's begin and after the interval's end. If more than one interval is specified, the query will connect them with the OR keyword. If either begin or end of an interval are null, these values will not be specified in the query.
    
    Parameters:
    
    intervals - - the TimeIntervals within which the task wasn't modified
    
    Returns:
    
    the query
  - orderByModified
```
TaskQuery orderByModified(BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to the modified timestamp.
    
    Parameters:
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query
  - plannedWithin
```
TaskQuery plannedWithin(TimeInterval... intervals)
```
    Add the time intervals within which the task is planned to your query. For each time interval, the database query will search for tasks whose planned timestamp is after or at the interval's begin and before or at the interval's end. If more than one interval is specified, the query will connect them with the OR keyword. If either begin or end of an interval are null, these values will not be specified in the query.
    
    Parameters:
    
    intervals - - the TimeIntervals within which the task is planned
    
    Returns:
    
    the query
  - plannedNotWithin
```
TaskQuery plannedNotWithin(TimeInterval... intervals)
```
    Exclude the time intervals within which the task isn't planned from your query. For each time interval, the database query will search for tasks whose planned timestamp is before the interval's begin and after the interval's end. If more than one interval is specified, the query will connect them with the OR keyword. If either begin or end of an interval are null, these values will not be specified in the query.
    
    Parameters:
    
    intervals - - the TimeIntervals within which the task isn't planned
    
    Returns:
    
    the query
  - orderByPlanned
```
TaskQuery orderByPlanned(BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to the planned timestamp.
    
    Parameters:
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query
  - dueWithin
```
TaskQuery dueWithin(TimeInterval... intervals)
```
    Add the time intervals within which the task is due to your query. For each time interval, the database query will search for tasks whose due timestamp is after or at the interval's begin and before or at the interval's end. If more than one interval is specified, the query will connect them with the OR keyword. If either begin or end of an interval are null, these values will not be specified in the query.
    
    Parameters:
    
    intervals - - the TimeIntervals within which the task is due
    
    Returns:
    
    the query
  - dueNotWithin
```
TaskQuery dueNotWithin(TimeInterval... intervals)
```
    Exclude the time intervals within which the task isn't due from your query. For each time interval, the database query will search for tasks whose due timestamp is before the interval's begin and after the interval's end. If more than one interval is specified, the query will connect them with the OR keyword. If either begin or end of an interval are null, these values will not be specified in the query.
    
    Parameters:
    
    intervals - - the TimeIntervals within which the task isn't due
    
    Returns:
    
    the query
  - orderByDue
```
TaskQuery orderByDue(BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to the due timestamp.
    
    Parameters:
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query
  - completedWithin
```
TaskQuery completedWithin(TimeInterval... intervals)
```
    Add the time intervals within which the task was completed to your query. For each time interval, the database query will search for tasks whose completed timestamp is before the interval's begin and after the interval's end. If more than one interval is specified, the query will connect them with the OR keyword. If either begin or end of an interval are null, these values will not be specified in the query.
    
    Parameters:
    
    intervals - - the TimeIntervals within which the task was completed
    
    Returns:
    
    the query
  - completedNotWithin
```
TaskQuery completedNotWithin(TimeInterval... intervals)
```
    Exclude the time intervals within which the task wasn't completed from your query. For each time interval, the database query will search for tasks whose completed timestamp is before the interval's begin and after the interval's end. If more than one interval is specified, the query will connect them with the OR keyword. If either begin or end of an interval are null, these values will not be specified in the query.
    
    Parameters:
    
    intervals - - the TimeIntervals within which the task wasn't completed
    
    Returns:
    
    the query
  - orderByCompleted
```
TaskQuery orderByCompleted(BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to the completed timestamp.
    
    Parameters:
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query
  - nameIn
```
TaskQuery nameIn(String... names)
```
    Add your names to your query.
    
    Parameters:
    
    names - the names as Strings
    
    Returns:
    
    the query
  - nameNotIn
```
TaskQuery nameNotIn(String... names)
```
    Exclude these names from your query.
    
    Parameters:
    
    names - the names as Strings
    
    Returns:
    
    the query
  - nameLike
```
TaskQuery nameLike(String... names)
```
    Add your name for pattern matching to your query. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    names - your names
    
    Returns:
    
    the query
  - nameNotLike
```
TaskQuery nameNotLike(String... names)
```
    Exclude these names for pattern matching from your query. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    names - your names
    
    Returns:
    
    the query
  - orderByName
```
TaskQuery orderByName(BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to name.
    
    Parameters:
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query
  - creatorIn
```
TaskQuery creatorIn(String... creators)
```
    Add the UserIds of the creator to your query.
    
    Parameters:
    
    creators - of the queried tasks
    
    Returns:
    
    the query
  - creatorNotIn
```
TaskQuery creatorNotIn(String... creators)
```
    Exclude the UserIds of the creator from your query.
    
    Parameters:
    
    creators - of the queried tasks
    
    Returns:
    
    the query
  - creatorLike
```
TaskQuery creatorLike(String... creators)
```
    Add the UserIds of the creator for pattern matching to your query. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    creators - of the queried tasks
    
    Returns:
    
    the query
  - creatorNotLike
```
TaskQuery creatorNotLike(String... creators)
```
    Exclude the UserIds of the creator for pattern matching from your query. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    creators - of the queried tasks
    
    Returns:
    
    the query
  - orderByCreator
```
TaskQuery orderByCreator(BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to creators name.
    
    Parameters:
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query
  - noteLike
```
TaskQuery noteLike(String... note)
```
    Add your custom note for pattern matching to your query. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    note - your custom note
    
    Returns:
    
    the query
  - noteNotLike
```
TaskQuery noteNotLike(String... note)
```
    Exclude your custom note for pattern matching from your query. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    note - your custom note
    
    Returns:
    
    the query
  - orderByNote
```
TaskQuery orderByNote(BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to the note.
    
    Parameters:
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query
  - descriptionLike
```
TaskQuery descriptionLike(String... description)
```
    Add your description for pattern matching to your query. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    description - your description
    
    Returns:
    
    the query
  - descriptionNotLike
```
TaskQuery descriptionNotLike(String... description)
```
    Exclude your description for pattern matching from your query. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    description - your description
    
    Returns:
    
    the query
  - priorityIn
```
TaskQuery priorityIn(int... priorities)
```
    Add your priorities to your query.
    
    Parameters:
    
    priorities - as a integer
    
    Returns:
    
    the query
  - priorityNotIn
```
TaskQuery priorityNotIn(int... priorities)
```
    Exclude the priorities from your query.
    
    Parameters:
    
    priorities - as a integer
    
    Returns:
    
    the query
  - orderByPriority
```
TaskQuery orderByPriority(BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to the priority.
    
    Parameters:
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query
  - stateIn
```
TaskQuery stateIn(TaskState... states)
```
    Add your state to your query.
    
    Parameters:
    
    states - the states as TaskState
    
    Returns:
    
    the query
  - stateNotIn
```
TaskQuery stateNotIn(TaskState... states)
```
    Exclude these states from your query.
    
    Parameters:
    
    states - the states as TaskState
    
    Returns:
    
    the query
  - orderByState
```
TaskQuery orderByState(BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to the state.
    
    Parameters:
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query
  - classificationIdIn
```
TaskQuery classificationIdIn(String... classificationIds)
```
    Add your classificationId to your query.
    
    Parameters:
    
    classificationIds - the classification Ids
    
    Returns:
    
    the query
  - classificationIdNotIn
```
TaskQuery classificationIdNotIn(String... classificationIds)
```
    Exclude these classificationIds from your query.
    
    Parameters:
    
    classificationIds - the classification Ids
    
    Returns:
    
    the query
  - classificationKeyIn
```
TaskQuery classificationKeyIn(String... classificationKeys)
```
    Add your classificationKey to your query.
    
    Parameters:
    
    classificationKeys - the classification key
    
    Returns:
    
    the query
  - classificationKeyNotIn
```
TaskQuery classificationKeyNotIn(String... classificationKeys)
```
    Exclude these classificationKeys from your query.
    
    Parameters:
    
    classificationKeys - the classification key
    
    Returns:
    
    the query
  - classificationKeyLike
```
TaskQuery classificationKeyLike(String... classificationKeys)
```
    Add your classificationKey for pattern matching to your query. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    classificationKeys - the classification key
    
    Returns:
    
    the query
  - classificationKeyNotLike
```
TaskQuery classificationKeyNotLike(String... classificationKeys)
```
    Exclude the classificationKeys for pattern matching from your query. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    classificationKeys - the classification key
    
    Returns:
    
    the query
  - orderByClassificationKey
```
TaskQuery orderByClassificationKey(BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to the classification key.
    
    Parameters:
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query
  - classificationCategoryIn
```
TaskQuery classificationCategoryIn(String... classificationCategories)
```
    Add your classificationCategory to your query.
    
    Parameters:
    
    classificationCategories - the classification category for filtering
    
    Returns:
    
    the query
  - classificationCategoryNotIn
```
TaskQuery classificationCategoryNotIn(String... classificationCategories)
```
    Exclude the classificationCategory from your query.
    
    Parameters:
    
    classificationCategories - the classification category for filtering
    
    Returns:
    
    the query
  - classificationCategoryLike
```
TaskQuery classificationCategoryLike(String... classificationCategories)
```
    Add your classificationCategory for pattern matching to your query. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    classificationCategories - the classification categories for filtering
    
    Returns:
    
    the query
  - classificationCategoryNotLike
```
TaskQuery classificationCategoryNotLike(String... classificationCategories)
```
    Exclude the classificationCategory for pattern matching from your query. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    classificationCategories - the classification categories for filtering
    
    Returns:
    
    the query
  - classificationNameIn
```
TaskQuery classificationNameIn(String... classificationNames)
```
    Add your classificationName to your query.
    
    Parameters:
    
    classificationNames - the classification name
    
    Returns:
    
    the query
  - classificationNameNotIn
```
TaskQuery classificationNameNotIn(String... classificationNames)
```
    Exclude the classificationName from your query.
    
    Parameters:
    
    classificationNames - the classification name
    
    Returns:
    
    the query
  - classificationNameLike
```
TaskQuery classificationNameLike(String... classificationNames)
```
    Add your classificationName for pattern matching to your query. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword. *
    
    Parameters:
    
    classificationNames - the classification name
    
    Returns:
    
    the query
  - classificationNameNotLike
```
TaskQuery classificationNameNotLike(String... classificationNames)
```
    Exclude the classificationName for pattern matching from your query. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword. *
    
    Parameters:
    
    classificationNames - the classification name
    
    Returns:
    
    the query
  - orderByClassificationName
```
TaskQuery orderByClassificationName(BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to the classification name.
    
    Parameters:
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query
  - workbasketIdIn
```
TaskQuery workbasketIdIn(String... workbasketIds)
```
    Add your workbasket id to the query.
    
    Parameters:
    
    workbasketIds - the ids of workbaskets
    
    Returns:
    
    the query
  - workbasketIdNotIn
```
TaskQuery workbasketIdNotIn(String... workbasketIds)
```
    Exclude the workbasket id from the query.
    
    Parameters:
    
    workbasketIds - the ids of workbaskets
    
    Returns:
    
    the query
  - orderByWorkbasketId
```
TaskQuery orderByWorkbasketId(BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to the workbasket-Id of the tasks.
    
    Parameters:
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query
  - workbasketKeyDomainIn
```
TaskQuery workbasketKeyDomainIn(KeyDomain... workbasketIdentifiers)
```
    Add your workbasket key to the query.
    
    Parameters:
    
    workbasketIdentifiers - the key - domain combinations that identify workbaskets
    
    Returns:
    
    the query
  - workbasketKeyDomainNotIn
```
TaskQuery workbasketKeyDomainNotIn(KeyDomain... workbasketIdentifiers)
```
    Exclude the workbasket key from the query.
    
    Parameters:
    
    workbasketIdentifiers - the key - domain combinations that identify workbaskets
    
    Returns:
    
    the query
  - ownerLongNameIn
```
TaskQuery ownerLongNameIn(String... longNames)
```
    Adds the long names of the owners to your query.
    
    Parameters:
    
    longNames - the long names as String
    
    Returns:
    
    the query
  - ownerLongNameNotIn
```
TaskQuery ownerLongNameNotIn(String... longNames)
```
    Adds the long names of the owners to your query, which should not be contained.
    
    Parameters:
    
    longNames - the long names as String
    
    Returns:
    
    the query
  - ownerLongNameLike
```
TaskQuery ownerLongNameLike(String... longNames)
```
    Adds the long names of the owner for pattern matching to your query. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern.
    If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    longNames - the owners of the searched tasks
    
    Returns:
    
    the query
  - ownerLongNameNotLike
```
TaskQuery ownerLongNameNotLike(String... longNames)
```
    Adds the long names of the owner for pattern matching to your query, which should not be contained. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern.
    If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    longNames - the owners of the searched tasks
    
    Returns:
    
    the query
  - businessProcessIdIn
```
TaskQuery businessProcessIdIn(String... businessProcessIds)
```
    Add the business process ids for exact matching to your query.
    
    Parameters:
    
    businessProcessIds - the businessProcessIds of the searched for tasks
    
    Returns:
    
    the query
  - businessProcessIdNotIn
```
TaskQuery businessProcessIdNotIn(String... businessProcessIds)
```
    Exclude the business process ids for exact matching from your query.
    
    Parameters:
    
    businessProcessIds - the businessProcessIds of the searched for tasks
    
    Returns:
    
    the query
  - businessProcessIdLike
```
TaskQuery businessProcessIdLike(String... businessProcessIds)
```
    Add your businessProcessId for pattern matching to your query. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword. *
    
    Parameters:
    
    businessProcessIds - the classification name
    
    Returns:
    
    the query
  - businessProcessIdNotLike
```
TaskQuery businessProcessIdNotLike(String... businessProcessIds)
```
    Exclude your businessProcessId for pattern matching to your query. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword. *
    
    Parameters:
    
    businessProcessIds - the classification name
    
    Returns:
    
    the query
  - orderByBusinessProcessId
```
TaskQuery orderByBusinessProcessId(BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to the business process id.
    
    Parameters:
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query
  - parentBusinessProcessIdIn
```
TaskQuery parentBusinessProcessIdIn(String... parentBusinessProcessIds)
```
    Add the parent business process ids for exact matching to your query.
    
    Parameters:
    
    parentBusinessProcessIds - the parent businessProcessIds of the searched for tasks
    
    Returns:
    
    the query
  - parentBusinessProcessIdNotIn
```
TaskQuery parentBusinessProcessIdNotIn(String... parentBusinessProcessIds)
```
    Exclude the parent business process ids for exact matching from your query.
    
    Parameters:
    
    parentBusinessProcessIds - the parent businessProcessIds of the searched for tasks
    
    Returns:
    
    the query
  - parentBusinessProcessIdLike
```
TaskQuery parentBusinessProcessIdLike(String... businessProcessIds)
```
    Add your parent business process id for pattern matching to your query. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword. *
    
    Parameters:
    
    businessProcessIds - the classification name
    
    Returns:
    
    the query
  - parentBusinessProcessIdNotLike
```
TaskQuery parentBusinessProcessIdNotLike(String... businessProcessIds)
```
    Exclude your parent business process id for pattern matching to your query. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword. *
    
    Parameters:
    
    businessProcessIds - the classification name
    
    Returns:
    
    the query
  - orderByParentBusinessProcessId
```
TaskQuery orderByParentBusinessProcessId(BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to the parent business process id.
    
    Parameters:
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query
  - ownerIn
```
TaskQuery ownerIn(String... owners)
```
    Add the owners to your query.
    
    Parameters:
    
    owners - the owners as String
    
    Returns:
    
    the query
  - ownerNotIn
```
TaskQuery ownerNotIn(String... owners)
```
    Filter out owners.
    
    Parameters:
    
    owners - the owners as String
    
    Returns:
    
    the query
  - ownerLike
```
TaskQuery ownerLike(String... owners)
```
    Add the owner for pattern matching to your query. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern.
    If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    owners - the owners of the searched tasks
    
    Returns:
    
    the query
  - ownerNotLike
```
TaskQuery ownerNotLike(String... owners)
```
    Exclude the owner for pattern matching from your query. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern.
    If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    owners - the owners of the searched tasks
    
    Returns:
    
    the query
  - orderByOwner
```
TaskQuery orderByOwner(BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to the owner.
    
    Parameters:
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query
  - primaryObjectReferenceIn
```
TaskQuery primaryObjectReferenceIn(ObjectReference... objectReferences)
```
    Add the ObjectReference to exact match to your query. Each individual value has to match. Fields with the value 'null' will be ignored. The id of each ObjectReference will be ignored
    If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    objectReferences - the combined values which are searched together.
    
    Returns:
    
    the query
  - primaryObjectReferenceCompanyIn
```
TaskQuery primaryObjectReferenceCompanyIn(String... companies)
```
    Add the companies of the primary object reference for exact matching to your query.
    
    Parameters:
    
    companies - the companies of your primary object reference
    
    Returns:
    
    the query
  - primaryObjectReferenceCompanyNotIn
```
TaskQuery primaryObjectReferenceCompanyNotIn(String... companies)
```
    Exclude the companies of the primary object reference for exact matching from your query.
    
    Parameters:
    
    companies - the companies of your primary object reference
    
    Returns:
    
    the query
  - primaryObjectReferenceCompanyLike
```
TaskQuery primaryObjectReferenceCompanyLike(String... company)
```
    Add the company of the primary object reference for pattern matching to your query. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    company - the company of your primary object reference
    
    Returns:
    
    the query
  - primaryObjectReferenceCompanyNotLike
```
TaskQuery primaryObjectReferenceCompanyNotLike(String... company)
```
    Exclude the company of the primary object reference for pattern matching from your query. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    company - the company of your primary object reference
    
    Returns:
    
    the query
  - orderByPrimaryObjectReferenceCompany
```
TaskQuery orderByPrimaryObjectReferenceCompany(BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to the company of the primary object reference.
    
    Parameters:
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query
  - primaryObjectReferenceSystemIn
```
TaskQuery primaryObjectReferenceSystemIn(String... systems)
```
    Add the systems of the primary object reference for exact matching to your query.
    
    Parameters:
    
    systems - the systems of your primary object reference
    
    Returns:
    
    the query
  - primaryObjectReferenceSystemNotIn
```
TaskQuery primaryObjectReferenceSystemNotIn(String... systems)
```
    Exclude the systems of the primary object reference for exact matching from your query.
    
    Parameters:
    
    systems - the systems of your primary object reference
    
    Returns:
    
    the query
  - primaryObjectReferenceSystemLike
```
TaskQuery primaryObjectReferenceSystemLike(String... systems)
```
    Add the system of the primary object reference for pattern matching to your query. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    systems - the system of your primary object reference
    
    Returns:
    
    the query
  - primaryObjectReferenceSystemNotLike
```
TaskQuery primaryObjectReferenceSystemNotLike(String... systems)
```
    Exclude the system of the primary object reference for pattern matching from your query. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    systems - the system of your primary object reference
    
    Returns:
    
    the query
  - orderByPrimaryObjectReferenceSystem
```
TaskQuery orderByPrimaryObjectReferenceSystem(BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to the system of the primary object reference.
    
    Parameters:
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query
  - primaryObjectReferenceSystemInstanceIn
```
TaskQuery primaryObjectReferenceSystemInstanceIn(String... systemInstances)
```
    Add the system instances of the primary object reference for exact matching to your query.
    
    Parameters:
    
    systemInstances - the system instances of your primary object reference
    
    Returns:
    
    the query
  - primaryObjectReferenceSystemInstanceNotIn
```
TaskQuery primaryObjectReferenceSystemInstanceNotIn(String... systemInstances)
```
    Exclude the system instances of the primary object reference for exact matching from your query.
    
    Parameters:
    
    systemInstances - the system instances of your primary object reference
    
    Returns:
    
    the query
  - primaryObjectReferenceSystemInstanceLike
```
TaskQuery primaryObjectReferenceSystemInstanceLike(String... systemInstances)
```
    Add the system instance of the primary object reference for pattern matching to your query. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    systemInstances - the system instances of your primary object reference
    
    Returns:
    
    the query
  - primaryObjectReferenceSystemInstanceNotLike
```
TaskQuery primaryObjectReferenceSystemInstanceNotLike(String... systemInstances)
```
    Exclude the system instance of the primary object reference for pattern matching from your query. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    systemInstances - the system instances of your primary object reference
    
    Returns:
    
    the query
  - orderByPrimaryObjectReferenceSystemInstance
```
TaskQuery orderByPrimaryObjectReferenceSystemInstance(BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to the system instance of the primary object reference.
    
    Parameters:
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query
  - primaryObjectReferenceTypeIn
```
TaskQuery primaryObjectReferenceTypeIn(String... types)
```
    Add the types of the primary object reference for exact matching to your query.
    
    Parameters:
    
    types - the types your primary object reference
    
    Returns:
    
    the query
  - primaryObjectReferenceTypeNotIn
```
TaskQuery primaryObjectReferenceTypeNotIn(String... types)
```
    Exclude the types of the primary object reference for exact matching from your query.
    
    Parameters:
    
    types - the types your primary object reference
    
    Returns:
    
    the query
  - primaryObjectReferenceTypeLike
```
TaskQuery primaryObjectReferenceTypeLike(String... types)
```
    Add the type of the primary object reference for pattern matching to your query. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    types - the types of your primary object reference
    
    Returns:
    
    the query
  - primaryObjectReferenceTypeNotLike
```
TaskQuery primaryObjectReferenceTypeNotLike(String... types)
```
    Exclude the type of the primary object reference for pattern matching from your query. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    types - the types of your primary object reference
    
    Returns:
    
    the query
  - orderByPrimaryObjectReferenceType
```
TaskQuery orderByPrimaryObjectReferenceType(BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to the type of the primary object reference.
    
    Parameters:
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query
  - primaryObjectReferenceValueIn
```
TaskQuery primaryObjectReferenceValueIn(String... values)
```
    Add the values of the primary object reference for exact matching to your query.
    
    Parameters:
    
    values - the values of your primary object reference
    
    Returns:
    
    the query
  - primaryObjectReferenceValueNotIn
```
TaskQuery primaryObjectReferenceValueNotIn(String... values)
```
    Exclude the values of the primary object reference for exact matching from your query.
    
    Parameters:
    
    values - the values of your primary object reference
    
    Returns:
    
    the query
  - primaryObjectReferenceValueLike
```
TaskQuery primaryObjectReferenceValueLike(String... values)
```
    Add the value of the primary object reference for pattern matching to your query. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    values - the values of your primary object reference
    
    Returns:
    
    the query
  - primaryObjectReferenceValueNotLike
```
TaskQuery primaryObjectReferenceValueNotLike(String... values)
```
    Exclude the value of the primary object reference for pattern matching from your query. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    values - the values of your primary object reference
    
    Returns:
    
    the query
  - orderByPrimaryObjectReferenceValue
```
TaskQuery orderByPrimaryObjectReferenceValue(BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to the value of the primary object reference.
    
    Parameters:
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query
  - readEquals
```
TaskQuery readEquals(Boolean isRead)
```
    Add the isRead flag to the query.
    
    Parameters:
    
    isRead - as Boolean. If null, it won't be integrated into the statement. You have to set false.
    
    Returns:
    
    the query
  - transferredEquals
```
TaskQuery transferredEquals(Boolean isTransferred)
```
    Add the isTransferred flag to the query.
    
    Parameters:
    
    isTransferred - as Boolean. If null, it won't be integrated into the statement. You have to set false.
    
    Returns:
    
    the query
  - attachmentClassificationIdIn
```
TaskQuery attachmentClassificationIdIn(String... attachmentClassificationId)
```
    Add the attachment classification Ids for exact matching to your query.
    
    Parameters:
    
    attachmentClassificationId - the attachmentClassificationId values of the searched for tasks
    
    Returns:
    
    the query
  - attachmentClassificationIdNotIn
```
TaskQuery attachmentClassificationIdNotIn(String... attachmentClassificationId)
```
    Exclude the attachment classification Ids for exact matching from your query.
    
    Parameters:
    
    attachmentClassificationId - the attachmentClassificationId values of the searched for tasks
    
    Returns:
    
    the query
  - orderByAttachmentClassificationId
```
TaskQuery orderByAttachmentClassificationId(BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to the attachment classification id. (Should only be used if there is one attachment per task in other case the result would be wrong.)
    
    Parameters:
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query
  - attachmentClassificationKeyIn
```
TaskQuery attachmentClassificationKeyIn(String... attachmentClassificationKeys)
```
    Add the attachment classification keys for exact matching to your query.
    
    Parameters:
    
    attachmentClassificationKeys - the attachmentClassificationKeys values of the searched for tasks
    
    Returns:
    
    the query
  - attachmentClassificationKeyNotIn
```
TaskQuery attachmentClassificationKeyNotIn(String... attachmentClassificationKeys)
```
    Exclude the attachment classification keys for exact matching from your query.
    
    Parameters:
    
    attachmentClassificationKeys - the attachmentClassificationKeys values of the searched for tasks
    
    Returns:
    
    the query
  - attachmentClassificationKeyLike
```
TaskQuery attachmentClassificationKeyLike(String... attachmentClassificationKey)
```
    Add the attachment classification Keys for pattern matching to your query. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    attachmentClassificationKey - the attachmentClassificationKeys values of the searched for tasks
    
    Returns:
    
    the query
  - attachmentClassificationKeyNotLike
```
TaskQuery attachmentClassificationKeyNotLike(String... attachmentClassificationKey)
```
    Exclude the attachment classification Keys for pattern matching from your query. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    attachmentClassificationKey - the attachmentClassificationKeys values of the searched for tasks
    
    Returns:
    
    the query
  - orderByAttachmentClassificationKey
```
TaskQuery orderByAttachmentClassificationKey(BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to the attachment classification key. (Should only be used if there is one attachment per task in other case the result would be wrong.)
    
    Parameters:
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query
  - attachmentClassificationNameIn
```
TaskQuery attachmentClassificationNameIn(String... attachmentClassificationName)
```
    Add the attachment classification names for exact matching to your query.
    
    Parameters:
    
    attachmentClassificationName - the attachmentClassificationName values of the searched for tasks
    
    Returns:
    
    the query
  - attachmentClassificationNameNotIn
```
TaskQuery attachmentClassificationNameNotIn(String... attachmentClassificationName)
```
    Exclude the attachment classification names for exact matching from your query.
    
    Parameters:
    
    attachmentClassificationName - the attachmentClassificationName values of the searched for tasks
    
    Returns:
    
    the query
  - attachmentClassificationNameLike
```
TaskQuery attachmentClassificationNameLike(String... attachmentClassificationName)
```
    Add the values of attachment classification names for pattern matching to your query. They will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    attachmentClassificationName - the attachmentClassificationName values of the searched-for tasks
    
    Returns:
    
    the query
  - attachmentClassificationNameNotLike
```
TaskQuery attachmentClassificationNameNotLike(String... attachmentClassificationName)
```
    Exclude the values of attachment classification names for pattern matching from your query. They will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    attachmentClassificationName - the attachmentClassificationName values of the searched-for tasks
    
    Returns:
    
    the query
  - orderByAttachmentClassificationName
```
TaskQuery orderByAttachmentClassificationName(BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to the attachment classification name. (Should only be used if there is one attachment per task in other case the result would be wrong.)
    
    Parameters:
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query
  - attachmentChannelIn
```
TaskQuery attachmentChannelIn(String... attachmentChannel)
```
    Add the values of attachment channel for exact matching to your query.
    
    Parameters:
    
    attachmentChannel - the attachmentChannel values of the searched for tasks
    
    Returns:
    
    the query
  - attachmentChannelNotIn
```
TaskQuery attachmentChannelNotIn(String... attachmentChannel)
```
    Exclude the values of attachment channel for exact matching from your query.
    
    Parameters:
    
    attachmentChannel - the attachmentChannel values of the searched for tasks
    
    Returns:
    
    the query
  - orderByOwnerLongName
```
TaskQuery orderByOwnerLongName(BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to the owner's long name. (Should only be used if each Task has an owner. Otherwise, the result is wrong.)
    
    Parameters:
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query
  - attachmentChannelLike
```
TaskQuery attachmentChannelLike(String... attachmentChannel)
```
    Add the values of attachment channel for pattern matching to your query. They will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    attachmentChannel - the attachmentChannel values of the searched-for tasks
    
    Returns:
    
    the query
  - attachmentChannelNotLike
```
TaskQuery attachmentChannelNotLike(String... attachmentChannel)
```
    Exclude the values of attachment channel for pattern matching from your query. They will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    attachmentChannel - the attachmentChannel values of the searched-for tasks
    
    Returns:
    
    the query
  - orderByAttachmentChannel
```
TaskQuery orderByAttachmentChannel(BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to the attachment channel. (Should only be used if there is one attachment per task in other case the result would be wrong.)
    
    Parameters:
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query
  - attachmentReferenceValueIn
```
TaskQuery attachmentReferenceValueIn(String... referenceValue)
```
    Add the values of reference values for exact matching to your query.
    
    Parameters:
    
    referenceValue - the referenceValue values of the searched for tasks
    
    Returns:
    
    the query
  - attachmentReferenceValueNotIn
```
TaskQuery attachmentReferenceValueNotIn(String... referenceValue)
```
    Exclude the values of reference values for exact matching from your query.
    
    Parameters:
    
    referenceValue - the referenceValue values of the searched for tasks
    
    Returns:
    
    the query
  - attachmentReferenceValueLike
```
TaskQuery attachmentReferenceValueLike(String... referenceValue)
```
    Add the values of reference values for pattern matching to your query. They will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    referenceValue - the referenceValue values of the searched-for tasks
    
    Returns:
    
    the query
  - attachmentReferenceValueNotLike
```
TaskQuery attachmentReferenceValueNotLike(String... referenceValue)
```
    Exclude the values of reference values for pattern matching to your query. They will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    referenceValue - the referenceValue values of the searched-for tasks
    
    Returns:
    
    the query
  - orderByAttachmentReference
```
TaskQuery orderByAttachmentReference(BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to the attachment reference value. (Should only be used if there is one attachment per task in other case the result would be wrong.)
    
    Parameters:
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query
  - attachmentReceivedWithin
```
TaskQuery attachmentReceivedWithin(TimeInterval... receivedIn)
```
    Add your received-dates to your query.
    
    Parameters:
    
    receivedIn - the TimeInterval within which the searched-for tasks attachment were received the last time.
    
    Returns:
    
    the query
  - attachmentNotReceivedWithin
```
TaskQuery attachmentNotReceivedWithin(TimeInterval... receivedNotIn)
```
    Exclude the received-dates from your query.
    
    Parameters:
    
    receivedNotIn - the TimeInterval within which the searched-for tasks attachment weren't received the last time.
    
    Returns:
    
    the query
  - orderByAttachmentReceived
```
TaskQuery orderByAttachmentReceived(BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to the attachment received. (Should only be used if there is one attachment per task in other case the result would be wrong.)
    
    Parameters:
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query
  - withoutAttachment
```
TaskQuery withoutAttachment()
```
    This method adds the condition that only Tasks that don't have any Attachments will be included in the TaskQuery.
    
    Returns:
    
    the TaskQuery
  - secondaryObjectReferenceIn
```
TaskQuery secondaryObjectReferenceIn(ObjectReference... objectReferences)
```
    Add the ObjectReference to exact match to your query. Each individual value has to match. Fields with the value 'null' will be ignored. The id of each ObjectReference will be ignored
    If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    objectReferences - the combined values which are searched together.
    
    Returns:
    
    the query
  - sorCompanyIn
```
TaskQuery sorCompanyIn(String... companyIn)
```
    Add the values of the company of at least one of the secondaryObjectReferences for exact matching to your query.
    
    Parameters:
    
    companyIn - the company values of the searched for Tasks
    
    Returns:
    
    the TaskQuery
  - sorCompanyLike
```
TaskQuery sorCompanyLike(String... companyLike)
```
    Add the values of company of at least one of the secondaryobjectReferences for pattern matching to your query. They will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    companyLike - the company values of the searched-for Tasks
    
    Returns:
    
    the TaskQuery
  - sorSystemIn
```
TaskQuery sorSystemIn(String... systemIn)
```
    Add the values of the system of at least one of the secondaryObjectReferences for exact matching to your query.
    
    Parameters:
    
    systemIn - the system values of the searched for Tasks
    
    Returns:
    
    the TaskQuery
  - sorSystemLike
```
TaskQuery sorSystemLike(String... systemLike)
```
    Add the values of system of at least one of the secondaryobjectReferences for pattern matching to your query. They will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    systemLike - the system values of the searched-for Tasks
    
    Returns:
    
    the TaskQuery
  - sorSystemInstanceIn
```
TaskQuery sorSystemInstanceIn(String... systemInstanceIn)
```
    Add the values of the systemInstance of at least one of the secondaryObjectReferences for exact matching to your query.
    
    Parameters:
    
    systemInstanceIn - the systemInstance values of the searched for Tasks
    
    Returns:
    
    the TaskQuery
  - sorSystemInstanceLike
```
TaskQuery sorSystemInstanceLike(String... systemInstanceLike)
```
    Add the values of systemInstance of at least one of the secondaryobjectReferences for pattern matching to your query. They will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    systemInstanceLike - the systemInstance values of the searched-for Tasks
    
    Returns:
    
    the TaskQuery
  - sorTypeIn
```
TaskQuery sorTypeIn(String... typeIn)
```
    Add the values of the type of at least one of the secondaryObjectReferences for exact matching to your query.
    
    Parameters:
    
    typeIn - the type values of the searched for Tasks
    
    Returns:
    
    the TaskQuery
  - sorTypeLike
```
TaskQuery sorTypeLike(String... typeLike)
```
    Add the values of type of at least one of the secondaryobjectReferences for pattern matching to your query. They will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    typeLike - the type values of the searched-for Tasks
    
    Returns:
    
    the TaskQuery
  - sorValueIn
```
TaskQuery sorValueIn(String... valueIn)
```
    Add the values of the value of at least one of the secondaryObjectReferences for exact matching to your query.
    
    Parameters:
    
    valueIn - the value values of the searched for Tasks
    
    Returns:
    
    the TaskQuery
  - sorValueLike
```
TaskQuery sorValueLike(String... valueLike)
```
    Add the values of value of at least one of the secondaryobjectReferences for pattern matching to your query. They will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    valueLike - the value values of the searched-for Tasks
    
    Returns:
    
    the TaskQuery
  - customAttributeIn
```
TaskQuery customAttributeIn(TaskCustomField customField,
                            String... searchArguments)
                     throws InvalidArgumentException
```
    Add the values of custom attributes for exact matching to your query.
    
    Parameters:
    
    customField - identifies which custom attribute is affected.
    
    searchArguments - the customField values of the searched for tasks
    
    Returns:
    
    the query
    
    Throws:
    
    InvalidArgumentException - if searchArguments are not given
  - customAttributeNotIn
```
TaskQuery customAttributeNotIn(TaskCustomField customField,
                               String... searchArguments)
                        throws InvalidArgumentException
```
    Exclude these values of custom attributes from your query.
    
    Parameters:
    
    customField - identifies which custom attribute is affected.
    
    searchArguments - the customField values of the searched for tasks
    
    Returns:
    
    the query
    
    Throws:
    
    InvalidArgumentException - if searchArguments are not given
  - customAttributeLike
```
TaskQuery customAttributeLike(TaskCustomField customField,
                              String... searchArguments)
                       throws InvalidArgumentException
```
    Add the values of custom attributes for pattern matching to your query. They will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    customField - identifies which custom attribute is affected.
    
    searchArguments - the customField values of the searched for tasks
    
    Returns:
    
    the query
    
    Throws:
    
    InvalidArgumentException - if searchArguments is not given
  - customAttributeNotLike
```
TaskQuery customAttributeNotLike(TaskCustomField customField,
                                 String... searchArguments)
                          throws InvalidArgumentException
```
    Exclude the values of custom attributes for pattern matching from your query. They will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. If you specify multiple arguments they are combined with the OR keyword.
    
    Parameters:
    
    customField - identifies which custom attribute is affected.
    
    searchArguments - the customField values of the searched for tasks
    
    Returns:
    
    the query
    
    Throws:
    
    InvalidArgumentException - if searchArguments is not given
  - orderByCustomAttribute
```
TaskQuery orderByCustomAttribute(TaskCustomField customField,
                                 BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to the value of a custom field.
    
    Parameters:
    
    customField - identifies which custom attribute is affected.
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query
  - callbackStateIn
```
TaskQuery callbackStateIn(CallbackState... states)
```
    Add your callbackState to your query.
    
    Parameters:
    
    states - the callback states as CallbackState
    
    Returns:
    
    the query
  - callbackStateNotIn
```
TaskQuery callbackStateNotIn(CallbackState... states)
```
    Exclude the callbackState from your query.
    
    Parameters:
    
    states - the callback states as CallbackState
    
    Returns:
    
    the query
  - wildcardSearchValueLike
```
TaskQuery wildcardSearchValueLike(String wildcardSearchValue)
```
    Add your wildcard search value for pattern matching to your query. It will be compared in SQL with the LIKE operator. You may use a wildcard like % to specify the pattern. Must be used in combination with the wildcardSearchFieldsIn parameter
    
    Parameters:
    
    wildcardSearchValue - the wildcard search value
    
    Returns:
    
    the query
  - wildcardSearchFieldsIn
```
TaskQuery wildcardSearchFieldsIn(WildcardSearchField... wildcardSearchFields)
```
    Add the Task fields for which the wildcard search should be performed as an exact match to your query. Must be used in combination with the wildcardSearchValueLike parameter
    
    Parameters:
    
    wildcardSearchFields - the Task fields of your wildcard search
    
    Returns:
    
    the query
  - createObjectReferenceQuery
```
ObjectReferenceQuery createObjectReferenceQuery()
```
    This method provides a query builder for quering the database.
    
    Returns:
    
    a ObjectReferenceQuery
  - orderByDomain
```
TaskQuery orderByDomain(BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to the domain.
    
    Parameters:
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query
  - orderByWorkbasketKey
```
TaskQuery orderByWorkbasketKey(BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to the workbasket key.
    
    Parameters:
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query
  - orderByWorkbasketName
```
TaskQuery orderByWorkbasketName(BaseQuery.SortDirection sortDirection)
```
    This method sorts the query result according to the workbasket name of the tasks.
    
    Parameters:
    
    sortDirection - Determines whether the result is sorted in ascending or descending order. If sortDirection is null, the result is sorted in ascending order
    
    Returns:
    
    the query

Interface TaskQuery

Nested Class Summary

Nested classes/interfaces inherited from interface pro.taskana.common.api.BaseQuery

Method Summary

Methods inherited from interface pro.taskana.common.api.BaseQuery

Method Detail

idIn

idNotIn

orderByTaskId

externalIdIn

externalIdNotIn

receivedWithin

receivedNotWithin

orderByReceived

createdWithin

createdNotWithin

orderByCreated

claimedWithin

claimedNotWithin

orderByClaimed

modifiedWithin

modifiedNotWithin

orderByModified

plannedWithin

plannedNotWithin

orderByPlanned

dueWithin

dueNotWithin

orderByDue

completedWithin

completedNotWithin

orderByCompleted

nameIn

nameNotIn

nameLike

nameNotLike

orderByName

creatorIn

creatorNotIn

creatorLike

creatorNotLike

orderByCreator

noteLike

noteNotLike

orderByNote

descriptionLike

descriptionNotLike

priorityIn

priorityNotIn

orderByPriority

stateIn

stateNotIn

orderByState

classificationIdIn

classificationIdNotIn

classificationKeyIn

classificationKeyNotIn

classificationKeyLike

classificationKeyNotLike

orderByClassificationKey

classificationCategoryIn

classificationCategoryNotIn

classificationCategoryLike

classificationCategoryNotLike

classificationNameIn

classificationNameNotIn

classificationNameLike

classificationNameNotLike

orderByClassificationName

workbasketIdIn

workbasketIdNotIn

orderByWorkbasketId

workbasketKeyDomainIn

workbasketKeyDomainNotIn

ownerLongNameIn

ownerLongNameNotIn

ownerLongNameLike

ownerLongNameNotLike

businessProcessIdIn

businessProcessIdNotIn