java.lang.Object
- pro.taskana.task.internal.TaskQueryImpl

All Implemented Interfaces:

BaseQuery<TaskSummary,TaskQueryColumnName>, TaskQuery
```
public class TaskQueryImpl
extends Object
implements TaskQuery
```
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 Concrete 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... classificationId)`	Add your classificationId to your query.
`TaskQuery`	`classificationIdNotIn(String... classificationIds)`	Exclude these classificationIds from your query.
`TaskQuery`	`classificationKeyIn(String... classificationKey)`	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.
`long`	`count()`
`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... strings)`	Add the values of custom attributes for exact matching to your query.
`TaskQuery`	`customAttributeLike(TaskCustomField customField, String... strings)`	Add the values of custom attributes for pattern matching to your query.
`TaskQuery`	`customAttributeNotIn(TaskCustomField customField, String... strings)`	Exclude these values of custom attributes from your query.
`TaskQuery`	`customAttributeNotLike(TaskCustomField customField, String... strings)`	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.
`String[]`	`getOwnerLongNameIn()`
`String[]`	`getOwnerLongNameLike()`
`String[]`	`getOwnerLongNameNotIn()`
`String[]`	`getOwnerLongNameNotLike()`
`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.
`List<TaskSummary>`	`list()`
`List<TaskSummary>`	`list(int offset, int limit)`
`List<String>`	`listValues(TaskQueryColumnName columnName, BaseQuery.SortDirection sortDirection)`
`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... systemInstance)`	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... system)`	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`	`selectAndClaimEquals(boolean selectAndClaim)`
`TaskSummary`	`single()`
`TaskQuery`	`stateIn(TaskState... states)`	Add your state to your query.
`TaskQuery`	`stateNotIn(TaskState... states)`	Exclude these states from your query.
`String`	`toString()`
`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`	`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 class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface pro.taskana.common.api.BaseQuery
listPage, toUpperCopy

- Method Detail
  - idIn
```
public TaskQuery idIn(String... taskIds)
```
    Description copied from interface: TaskQuery
    
    Filter for summaries which contain one of the given taskIds.
    
    Specified by:
    
    idIn in interface TaskQuery
    
    Parameters:
    
    taskIds - The ids of the searched-for tasks.
    
    Returns:
    
    the taskQuery
  - idNotIn
```
public TaskQuery idNotIn(String... taskIds)
```
    Description copied from interface: TaskQuery
    
    Exclude summaries which contain one of the given taskIds.
    
    Specified by:
    
    idNotIn in interface TaskQuery
    
    Parameters:
    
    taskIds - The ids of the searched-for tasks.
    
    Returns:
    
    the taskQuery
  - orderByTaskId
```
public TaskQuery orderByTaskId(BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    This method sorts the query result according to the primary task id.
    
    Specified by:
    
    orderByTaskId in interface TaskQuery
    
    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
```
public TaskQuery externalIdIn(String... externalIds)
```
    Description copied from interface: TaskQuery
    
    Add your external ids to your query.
    
    Specified by:
    
    externalIdIn in interface TaskQuery
    
    Parameters:
    
    externalIds - the external ids as Strings
    
    Returns:
    
    the query
  - externalIdNotIn
```
public TaskQuery externalIdNotIn(String... externalIds)
```
    Description copied from interface: TaskQuery
    
    Exclude these external ids from your query.
    
    Specified by:
    
    externalIdNotIn in interface TaskQuery
    
    Parameters:
    
    externalIds - the external ids as Strings
    
    Returns:
    
    the query
  - receivedWithin
```
public TaskQuery receivedWithin(TimeInterval... intervals)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    receivedWithin in interface TaskQuery
    
    Parameters:
    
    intervals - - the TimeIntervals within which the task is received
    
    Returns:
    
    the query
  - receivedNotWithin
```
public TaskQuery receivedNotWithin(TimeInterval... intervals)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    receivedNotWithin in interface TaskQuery
    
    Parameters:
    
    intervals - - the TimeIntervals within which the task wasn't received
    
    Returns:
    
    the query
  - orderByReceived
```
public TaskQuery orderByReceived(BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    This method sorts the query result according to the received timestamp.
    
    Specified by:
    
    orderByReceived in interface TaskQuery
    
    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
```
public TaskQuery createdWithin(TimeInterval... intervals)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    createdWithin in interface TaskQuery
    
    Parameters:
    
    intervals - - the TimeIntervals within which the task was created
    
    Returns:
    
    the query
  - createdNotWithin
```
public TaskQuery createdNotWithin(TimeInterval... intervals)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    createdNotWithin in interface TaskQuery
    
    Parameters:
    
    intervals - - the TimeIntervals within which the task wasn't created
    
    Returns:
    
    the query
  - orderByCreated
```
public TaskQuery orderByCreated(BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    This method sorts the query result according to the created timestamp.
    
    Specified by:
    
    orderByCreated in interface TaskQuery
    
    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
```
public TaskQuery claimedWithin(TimeInterval... intervals)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    claimedWithin in interface TaskQuery
    
    Parameters:
    
    intervals - - the TimeIntervals within which the task was claimed
    
    Returns:
    
    the query
  - claimedNotWithin
```
public TaskQuery claimedNotWithin(TimeInterval... intervals)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    claimedNotWithin in interface TaskQuery
    
    Parameters:
    
    intervals - - the TimeIntervals within which the task wasn't claimed
    
    Returns:
    
    the query
  - orderByClaimed
```
public TaskQuery orderByClaimed(BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    This method sorts the query result according to the claimed timestamp.
    
    Specified by:
    
    orderByClaimed in interface TaskQuery
    
    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
```
public TaskQuery modifiedWithin(TimeInterval... intervals)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    modifiedWithin in interface TaskQuery
    
    Parameters:
    
    intervals - - the TimeIntervals within which the task was modified
    
    Returns:
    
    the query
  - modifiedNotWithin
```
public TaskQuery modifiedNotWithin(TimeInterval... intervals)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    modifiedNotWithin in interface TaskQuery
    
    Parameters:
    
    intervals - - the TimeIntervals within which the task wasn't modified
    
    Returns:
    
    the query
  - orderByModified
```
public TaskQuery orderByModified(BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    This method sorts the query result according to the modified timestamp.
    
    Specified by:
    
    orderByModified in interface TaskQuery
    
    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
```
public TaskQuery plannedWithin(TimeInterval... intervals)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    plannedWithin in interface TaskQuery
    
    Parameters:
    
    intervals - - the TimeIntervals within which the task is planned
    
    Returns:
    
    the query
  - plannedNotWithin
```
public TaskQuery plannedNotWithin(TimeInterval... intervals)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    plannedNotWithin in interface TaskQuery
    
    Parameters:
    
    intervals - - the TimeIntervals within which the task isn't planned
    
    Returns:
    
    the query
  - orderByPlanned
```
public TaskQuery orderByPlanned(BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    This method sorts the query result according to the planned timestamp.
    
    Specified by:
    
    orderByPlanned in interface TaskQuery
    
    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
```
public TaskQuery dueWithin(TimeInterval... intervals)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    dueWithin in interface TaskQuery
    
    Parameters:
    
    intervals - - the TimeIntervals within which the task is due
    
    Returns:
    
    the query
  - dueNotWithin
```
public TaskQuery dueNotWithin(TimeInterval... intervals)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    dueNotWithin in interface TaskQuery
    
    Parameters:
    
    intervals - - the TimeIntervals within which the task isn't due
    
    Returns:
    
    the query
  - orderByDue
```
public TaskQuery orderByDue(BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    This method sorts the query result according to the due timestamp.
    
    Specified by:
    
    orderByDue in interface TaskQuery
    
    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
```
public TaskQuery completedWithin(TimeInterval... intervals)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    completedWithin in interface TaskQuery
    
    Parameters:
    
    intervals - - the TimeIntervals within which the task was completed
    
    Returns:
    
    the query
  - completedNotWithin
```
public TaskQuery completedNotWithin(TimeInterval... intervals)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    completedNotWithin in interface TaskQuery
    
    Parameters:
    
    intervals - - the TimeIntervals within which the task wasn't completed
    
    Returns:
    
    the query
  - orderByCompleted
```
public TaskQuery orderByCompleted(BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    This method sorts the query result according to the completed timestamp.
    
    Specified by:
    
    orderByCompleted in interface TaskQuery
    
    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
```
public TaskQuery nameIn(String... names)
```
    Description copied from interface: TaskQuery
    
    Add your names to your query.
    
    Specified by:
    
    nameIn in interface TaskQuery
    
    Parameters:
    
    names - the names as Strings
    
    Returns:
    
    the query
  - nameNotIn
```
public TaskQuery nameNotIn(String... names)
```
    Description copied from interface: TaskQuery
    
    Exclude these names from your query.
    
    Specified by:
    
    nameNotIn in interface TaskQuery
    
    Parameters:
    
    names - the names as Strings
    
    Returns:
    
    the query
  - nameLike
```
public TaskQuery nameLike(String... names)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    nameLike in interface TaskQuery
    
    Parameters:
    
    names - your names
    
    Returns:
    
    the query
  - nameNotLike
```
public TaskQuery nameNotLike(String... names)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    nameNotLike in interface TaskQuery
    
    Parameters:
    
    names - your names
    
    Returns:
    
    the query
  - orderByName
```
public TaskQuery orderByName(BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    This method sorts the query result according to name.
    
    Specified by:
    
    orderByName in interface TaskQuery
    
    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
```
public TaskQuery creatorIn(String... creators)
```
    Description copied from interface: TaskQuery
    
    Add the UserIds of the creator to your query.
    
    Specified by:
    
    creatorIn in interface TaskQuery
    
    Parameters:
    
    creators - of the queried tasks
    
    Returns:
    
    the query
  - creatorNotIn
```
public TaskQuery creatorNotIn(String... creators)
```
    Description copied from interface: TaskQuery
    
    Exclude the UserIds of the creator from your query.
    
    Specified by:
    
    creatorNotIn in interface TaskQuery
    
    Parameters:
    
    creators - of the queried tasks
    
    Returns:
    
    the query
  - creatorLike
```
public TaskQuery creatorLike(String... creators)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    creatorLike in interface TaskQuery
    
    Parameters:
    
    creators - of the queried tasks
    
    Returns:
    
    the query
  - creatorNotLike
```
public TaskQuery creatorNotLike(String... creators)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    creatorNotLike in interface TaskQuery
    
    Parameters:
    
    creators - of the queried tasks
    
    Returns:
    
    the query
  - orderByCreator
```
public TaskQuery orderByCreator(BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    This method sorts the query result according to creators name.
    
    Specified by:
    
    orderByCreator in interface TaskQuery
    
    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
```
public TaskQuery noteLike(String... note)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    noteLike in interface TaskQuery
    
    Parameters:
    
    note - your custom note
    
    Returns:
    
    the query
  - noteNotLike
```
public TaskQuery noteNotLike(String... note)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    noteNotLike in interface TaskQuery
    
    Parameters:
    
    note - your custom note
    
    Returns:
    
    the query
  - orderByNote
```
public TaskQuery orderByNote(BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    This method sorts the query result according to the note.
    
    Specified by:
    
    orderByNote in interface TaskQuery
    
    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
```
public TaskQuery descriptionLike(String... description)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    descriptionLike in interface TaskQuery
    
    Parameters:
    
    description - your description
    
    Returns:
    
    the query
  - descriptionNotLike
```
public TaskQuery descriptionNotLike(String... description)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    descriptionNotLike in interface TaskQuery
    
    Parameters:
    
    description - your description
    
    Returns:
    
    the query
  - priorityIn
```
public TaskQuery priorityIn(int... priorities)
```
    Description copied from interface: TaskQuery
    
    Add your priorities to your query.
    
    Specified by:
    
    priorityIn in interface TaskQuery
    
    Parameters:
    
    priorities - as a integer
    
    Returns:
    
    the query
  - priorityNotIn
```
public TaskQuery priorityNotIn(int... priorities)
```
    Description copied from interface: TaskQuery
    
    Exclude the priorities from your query.
    
    Specified by:
    
    priorityNotIn in interface TaskQuery
    
    Parameters:
    
    priorities - as a integer
    
    Returns:
    
    the query
  - orderByPriority
```
public TaskQuery orderByPriority(BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    This method sorts the query result according to the priority.
    
    Specified by:
    
    orderByPriority in interface TaskQuery
    
    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
```
public TaskQuery stateIn(TaskState... states)
```
    Description copied from interface: TaskQuery
    
    Add your state to your query.
    
    Specified by:
    
    stateIn in interface TaskQuery
    
    Parameters:
    
    states - the states as TaskState
    
    Returns:
    
    the query
  - stateNotIn
```
public TaskQuery stateNotIn(TaskState... states)
```
    Description copied from interface: TaskQuery
    
    Exclude these states from your query.
    
    Specified by:
    
    stateNotIn in interface TaskQuery
    
    Parameters:
    
    states - the states as TaskState
    
    Returns:
    
    the query
  - orderByState
```
public TaskQuery orderByState(BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    This method sorts the query result according to the state.
    
    Specified by:
    
    orderByState in interface TaskQuery
    
    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
```
public TaskQuery classificationIdIn(String... classificationId)
```
    Description copied from interface: TaskQuery
    
    Add your classificationId to your query.
    
    Specified by:
    
    classificationIdIn in interface TaskQuery
    
    Parameters:
    
    classificationId - the classification Ids
    
    Returns:
    
    the query
  - classificationIdNotIn
```
public TaskQuery classificationIdNotIn(String... classificationIds)
```
    Description copied from interface: TaskQuery
    
    Exclude these classificationIds from your query.
    
    Specified by:
    
    classificationIdNotIn in interface TaskQuery
    
    Parameters:
    
    classificationIds - the classification Ids
    
    Returns:
    
    the query
  - classificationKeyIn
```
public TaskQuery classificationKeyIn(String... classificationKey)
```
    Description copied from interface: TaskQuery
    
    Add your classificationKey to your query.
    
    Specified by:
    
    classificationKeyIn in interface TaskQuery
    
    Parameters:
    
    classificationKey - the classification key
    
    Returns:
    
    the query
  - classificationKeyNotIn
```
public TaskQuery classificationKeyNotIn(String... classificationKeys)
```
    Description copied from interface: TaskQuery
    
    Exclude these classificationKeys from your query.
    
    Specified by:
    
    classificationKeyNotIn in interface TaskQuery
    
    Parameters:
    
    classificationKeys - the classification key
    
    Returns:
    
    the query
  - classificationKeyLike
```
public TaskQuery classificationKeyLike(String... classificationKeys)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    classificationKeyLike in interface TaskQuery
    
    Parameters:
    
    classificationKeys - the classification key
    
    Returns:
    
    the query
  - classificationKeyNotLike
```
public TaskQuery classificationKeyNotLike(String... classificationKeys)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    classificationKeyNotLike in interface TaskQuery
    
    Parameters:
    
    classificationKeys - the classification key
    
    Returns:
    
    the query
  - orderByClassificationKey
```
public TaskQuery orderByClassificationKey(BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    This method sorts the query result according to the classification key.
    
    Specified by:
    
    orderByClassificationKey in interface TaskQuery
    
    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
```
public TaskQuery classificationCategoryIn(String... classificationCategories)
```
    Description copied from interface: TaskQuery
    
    Add your classificationCategory to your query.
    
    Specified by:
    
    classificationCategoryIn in interface TaskQuery
    
    Parameters:
    
    classificationCategories - the classification category for filtering
    
    Returns:
    
    the query
  - classificationCategoryNotIn
```
public TaskQuery classificationCategoryNotIn(String... classificationCategories)
```
    Description copied from interface: TaskQuery
    
    Exclude the classificationCategory from your query.
    
    Specified by:
    
    classificationCategoryNotIn in interface TaskQuery
    
    Parameters:
    
    classificationCategories - the classification category for filtering
    
    Returns:
    
    the query
  - classificationCategoryLike
```
public TaskQuery classificationCategoryLike(String... classificationCategories)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    classificationCategoryLike in interface TaskQuery
    
    Parameters:
    
    classificationCategories - the classification categories for filtering
    
    Returns:
    
    the query
  - classificationCategoryNotLike
```
public TaskQuery classificationCategoryNotLike(String... classificationCategories)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    classificationCategoryNotLike in interface TaskQuery
    
    Parameters:
    
    classificationCategories - the classification categories for filtering
    
    Returns:
    
    the query
  - classificationNameIn
```
public TaskQuery classificationNameIn(String... classificationNames)
```
    Description copied from interface: TaskQuery
    
    Add your classificationName to your query.
    
    Specified by:
    
    classificationNameIn in interface TaskQuery
    
    Parameters:
    
    classificationNames - the classification name
    
    Returns:
    
    the query
  - classificationNameNotIn
```
public TaskQuery classificationNameNotIn(String... classificationNames)
```
    Description copied from interface: TaskQuery
    
    Exclude the classificationName from your query.
    
    Specified by:
    
    classificationNameNotIn in interface TaskQuery
    
    Parameters:
    
    classificationNames - the classification name
    
    Returns:
    
    the query
  - classificationNameLike
```
public TaskQuery classificationNameLike(String... classificationNames)
```
    Description copied from interface: TaskQuery
    
    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. *
    
    Specified by:
    
    classificationNameLike in interface TaskQuery
    
    Parameters:
    
    classificationNames - the classification name
    
    Returns:
    
    the query
  - classificationNameNotLike
```
public TaskQuery classificationNameNotLike(String... classificationNames)
```
    Description copied from interface: TaskQuery
    
    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. *
    
    Specified by:
    
    classificationNameNotLike in interface TaskQuery
    
    Parameters:
    
    classificationNames - the classification name
    
    Returns:
    
    the query
  - orderByClassificationName
```
public TaskQuery orderByClassificationName(BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    This method sorts the query result according to the classification name.
    
    Specified by:
    
    orderByClassificationName in interface TaskQuery
    
    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
```
public TaskQuery workbasketIdIn(String... workbasketIds)
```
    Description copied from interface: TaskQuery
    
    Add your workbasket id to the query.
    
    Specified by:
    
    workbasketIdIn in interface TaskQuery
    
    Parameters:
    
    workbasketIds - the ids of workbaskets
    
    Returns:
    
    the query
  - workbasketIdNotIn
```
public TaskQuery workbasketIdNotIn(String... workbasketIds)
```
    Description copied from interface: TaskQuery
    
    Exclude the workbasket id from the query.
    
    Specified by:
    
    workbasketIdNotIn in interface TaskQuery
    
    Parameters:
    
    workbasketIds - the ids of workbaskets
    
    Returns:
    
    the query
  - orderByWorkbasketId
```
public TaskQuery orderByWorkbasketId(BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    This method sorts the query result according to the workbasket-Id of the tasks.
    
    Specified by:
    
    orderByWorkbasketId in interface TaskQuery
    
    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
```
public TaskQuery workbasketKeyDomainIn(KeyDomain... workbasketIdentifiers)
```
    Description copied from interface: TaskQuery
    
    Add your workbasket key to the query.
    
    Specified by:
    
    workbasketKeyDomainIn in interface TaskQuery
    
    Parameters:
    
    workbasketIdentifiers - the key - domain combinations that identify workbaskets
    
    Returns:
    
    the query
  - workbasketKeyDomainNotIn
```
public TaskQuery workbasketKeyDomainNotIn(KeyDomain... workbasketIdentifiers)
```
    Description copied from interface: TaskQuery
    
    Exclude the workbasket key from the query.
    
    Specified by:
    
    workbasketKeyDomainNotIn in interface TaskQuery
    
    Parameters:
    
    workbasketIdentifiers - the key - domain combinations that identify workbaskets
    
    Returns:
    
    the query
  - businessProcessIdIn
```
public TaskQuery businessProcessIdIn(String... businessProcessIds)
```
    Description copied from interface: TaskQuery
    
    Add the business process ids for exact matching to your query.
    
    Specified by:
    
    businessProcessIdIn in interface TaskQuery
    
    Parameters:
    
    businessProcessIds - the businessProcessIds of the searched for tasks
    
    Returns:
    
    the query
  - businessProcessIdNotIn
```
public TaskQuery businessProcessIdNotIn(String... businessProcessIds)
```
    Description copied from interface: TaskQuery
    
    Exclude the business process ids for exact matching from your query.
    
    Specified by:
    
    businessProcessIdNotIn in interface TaskQuery
    
    Parameters:
    
    businessProcessIds - the businessProcessIds of the searched for tasks
    
    Returns:
    
    the query
  - businessProcessIdLike
```
public TaskQuery businessProcessIdLike(String... businessProcessIds)
```
    Description copied from interface: TaskQuery
    
    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. *
    
    Specified by:
    
    businessProcessIdLike in interface TaskQuery
    
    Parameters:
    
    businessProcessIds - the classification name
    
    Returns:
    
    the query
  - businessProcessIdNotLike
```
public TaskQuery businessProcessIdNotLike(String... businessProcessIds)
```
    Description copied from interface: TaskQuery
    
    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. *
    
    Specified by:
    
    businessProcessIdNotLike in interface TaskQuery
    
    Parameters:
    
    businessProcessIds - the classification name
    
    Returns:
    
    the query
  - orderByBusinessProcessId
```
public TaskQuery orderByBusinessProcessId(BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    This method sorts the query result according to the business process id.
    
    Specified by:
    
    orderByBusinessProcessId in interface TaskQuery
    
    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
```
public TaskQuery parentBusinessProcessIdIn(String... parentBusinessProcessIds)
```
    Description copied from interface: TaskQuery
    
    Add the parent business process ids for exact matching to your query.
    
    Specified by:
    
    parentBusinessProcessIdIn in interface TaskQuery
    
    Parameters:
    
    parentBusinessProcessIds - the parent businessProcessIds of the searched for tasks
    
    Returns:
    
    the query
  - parentBusinessProcessIdNotIn
```
public TaskQuery parentBusinessProcessIdNotIn(String... parentBusinessProcessIds)
```
    Description copied from interface: TaskQuery
    
    Exclude the parent business process ids for exact matching from your query.
    
    Specified by:
    
    parentBusinessProcessIdNotIn in interface TaskQuery
    
    Parameters:
    
    parentBusinessProcessIds - the parent businessProcessIds of the searched for tasks
    
    Returns:
    
    the query
  - parentBusinessProcessIdLike
```
public TaskQuery parentBusinessProcessIdLike(String... businessProcessIds)
```
    Description copied from interface: TaskQuery
    
    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. *
    
    Specified by:
    
    parentBusinessProcessIdLike in interface TaskQuery
    
    Parameters:
    
    businessProcessIds - the classification name
    
    Returns:
    
    the query
  - parentBusinessProcessIdNotLike
```
public TaskQuery parentBusinessProcessIdNotLike(String... businessProcessIds)
```
    Description copied from interface: TaskQuery
    
    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. *
    
    Specified by:
    
    parentBusinessProcessIdNotLike in interface TaskQuery
    
    Parameters:
    
    businessProcessIds - the classification name
    
    Returns:
    
    the query
  - orderByParentBusinessProcessId
```
public TaskQuery orderByParentBusinessProcessId(BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    This method sorts the query result according to the parent business process id.
    
    Specified by:
    
    orderByParentBusinessProcessId in interface TaskQuery
    
    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
```
public TaskQuery ownerIn(String... owners)
```
    Description copied from interface: TaskQuery
    
    Add the owners to your query.
    
    Specified by:
    
    ownerIn in interface TaskQuery
    
    Parameters:
    
    owners - the owners as String
    
    Returns:
    
    the query
  - ownerNotIn
```
public TaskQuery ownerNotIn(String... owners)
```
    Description copied from interface: TaskQuery
    
    Filter out owners.
    
    Specified by:
    
    ownerNotIn in interface TaskQuery
    
    Parameters:
    
    owners - the owners as String
    
    Returns:
    
    the query
  - ownerLike
```
public TaskQuery ownerLike(String... owners)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    ownerLike in interface TaskQuery
    
    Parameters:
    
    owners - the owners of the searched tasks
    
    Returns:
    
    the query
  - ownerNotLike
```
public TaskQuery ownerNotLike(String... owners)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    ownerNotLike in interface TaskQuery
    
    Parameters:
    
    owners - the owners of the searched tasks
    
    Returns:
    
    the query
  - orderByOwner
```
public TaskQuery orderByOwner(BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    This method sorts the query result according to the owner.
    
    Specified by:
    
    orderByOwner in interface TaskQuery
    
    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
  - ownerLongNameIn
```
public TaskQuery ownerLongNameIn(String... longNames)
```
    Description copied from interface: TaskQuery
    
    Adds the long names of the owners to your query.
    
    Specified by:
    
    ownerLongNameIn in interface TaskQuery
    
    Parameters:
    
    longNames - the long names as String
    
    Returns:
    
    the query
  - ownerLongNameNotIn
```
public TaskQuery ownerLongNameNotIn(String... longNames)
```
    Description copied from interface: TaskQuery
    
    Adds the long names of the owners to your query, which should not be contained.
    
    Specified by:
    
    ownerLongNameNotIn in interface TaskQuery
    
    Parameters:
    
    longNames - the long names as String
    
    Returns:
    
    the query
  - ownerLongNameLike
```
public TaskQuery ownerLongNameLike(String... longNames)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    ownerLongNameLike in interface TaskQuery
    
    Parameters:
    
    longNames - the owners of the searched tasks
    
    Returns:
    
    the query
  - ownerLongNameNotLike
```
public TaskQuery ownerLongNameNotLike(String... longNames)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    ownerLongNameNotLike in interface TaskQuery
    
    Parameters:
    
    longNames - the owners of the searched tasks
    
    Returns:
    
    the query
  - primaryObjectReferenceIn
```
public TaskQuery primaryObjectReferenceIn(ObjectReference... objectReferences)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    primaryObjectReferenceIn in interface TaskQuery
    
    Parameters:
    
    objectReferences - the combined values which are searched together.
    
    Returns:
    
    the query
  - primaryObjectReferenceCompanyIn
```
public TaskQuery primaryObjectReferenceCompanyIn(String... companies)
```
    Description copied from interface: TaskQuery
    
    Add the companies of the primary object reference for exact matching to your query.
    
    Specified by:
    
    primaryObjectReferenceCompanyIn in interface TaskQuery
    
    Parameters:
    
    companies - the companies of your primary object reference
    
    Returns:
    
    the query
  - primaryObjectReferenceCompanyNotIn
```
public TaskQuery primaryObjectReferenceCompanyNotIn(String... companies)
```
    Description copied from interface: TaskQuery
    
    Exclude the companies of the primary object reference for exact matching from your query.
    
    Specified by:
    
    primaryObjectReferenceCompanyNotIn in interface TaskQuery
    
    Parameters:
    
    companies - the companies of your primary object reference
    
    Returns:
    
    the query
  - primaryObjectReferenceCompanyLike
```
public TaskQuery primaryObjectReferenceCompanyLike(String... company)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    primaryObjectReferenceCompanyLike in interface TaskQuery
    
    Parameters:
    
    company - the company of your primary object reference
    
    Returns:
    
    the query
  - primaryObjectReferenceCompanyNotLike
```
public TaskQuery primaryObjectReferenceCompanyNotLike(String... company)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    primaryObjectReferenceCompanyNotLike in interface TaskQuery
    
    Parameters:
    
    company - the company of your primary object reference
    
    Returns:
    
    the query
  - orderByPrimaryObjectReferenceCompany
```
public TaskQuery orderByPrimaryObjectReferenceCompany(BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    This method sorts the query result according to the company of the primary object reference.
    
    Specified by:
    
    orderByPrimaryObjectReferenceCompany in interface TaskQuery
    
    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
```
public TaskQuery primaryObjectReferenceSystemIn(String... systems)
```
    Description copied from interface: TaskQuery
    
    Add the systems of the primary object reference for exact matching to your query.
    
    Specified by:
    
    primaryObjectReferenceSystemIn in interface TaskQuery
    
    Parameters:
    
    systems - the systems of your primary object reference
    
    Returns:
    
    the query
  - primaryObjectReferenceSystemNotIn
```
public TaskQuery primaryObjectReferenceSystemNotIn(String... systems)
```
    Description copied from interface: TaskQuery
    
    Exclude the systems of the primary object reference for exact matching from your query.
    
    Specified by:
    
    primaryObjectReferenceSystemNotIn in interface TaskQuery
    
    Parameters:
    
    systems - the systems of your primary object reference
    
    Returns:
    
    the query
  - primaryObjectReferenceSystemLike
```
public TaskQuery primaryObjectReferenceSystemLike(String... system)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    primaryObjectReferenceSystemLike in interface TaskQuery
    
    Parameters:
    
    system - the system of your primary object reference
    
    Returns:
    
    the query
  - primaryObjectReferenceSystemNotLike
```
public TaskQuery primaryObjectReferenceSystemNotLike(String... systems)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    primaryObjectReferenceSystemNotLike in interface TaskQuery
    
    Parameters:
    
    systems - the system of your primary object reference
    
    Returns:
    
    the query
  - orderByPrimaryObjectReferenceSystem
```
public TaskQuery orderByPrimaryObjectReferenceSystem(BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    This method sorts the query result according to the system of the primary object reference.
    
    Specified by:
    
    orderByPrimaryObjectReferenceSystem in interface TaskQuery
    
    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
```
public TaskQuery primaryObjectReferenceSystemInstanceIn(String... systemInstances)
```
    Description copied from interface: TaskQuery
    
    Add the system instances of the primary object reference for exact matching to your query.
    
    Specified by:
    
    primaryObjectReferenceSystemInstanceIn in interface TaskQuery
    
    Parameters:
    
    systemInstances - the system instances of your primary object reference
    
    Returns:
    
    the query
  - primaryObjectReferenceSystemInstanceNotIn
```
public TaskQuery primaryObjectReferenceSystemInstanceNotIn(String... systemInstances)
```
    Description copied from interface: TaskQuery
    
    Exclude the system instances of the primary object reference for exact matching from your query.
    
    Specified by:
    
    primaryObjectReferenceSystemInstanceNotIn in interface TaskQuery
    
    Parameters:
    
    systemInstances - the system instances of your primary object reference
    
    Returns:
    
    the query
  - primaryObjectReferenceSystemInstanceLike
```
public TaskQuery primaryObjectReferenceSystemInstanceLike(String... systemInstance)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    primaryObjectReferenceSystemInstanceLike in interface TaskQuery
    
    Parameters:
    
    systemInstance - the system instances of your primary object reference
    
    Returns:
    
    the query
  - primaryObjectReferenceSystemInstanceNotLike
```
public TaskQuery primaryObjectReferenceSystemInstanceNotLike(String... systemInstances)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    primaryObjectReferenceSystemInstanceNotLike in interface TaskQuery
    
    Parameters:
    
    systemInstances - the system instances of your primary object reference
    
    Returns:
    
    the query
  - orderByPrimaryObjectReferenceSystemInstance
```
public TaskQuery orderByPrimaryObjectReferenceSystemInstance(BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    This method sorts the query result according to the system instance of the primary object reference.
    
    Specified by:
    
    orderByPrimaryObjectReferenceSystemInstance in interface TaskQuery
    
    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
```
public TaskQuery primaryObjectReferenceTypeIn(String... types)
```
    Description copied from interface: TaskQuery
    
    Add the types of the primary object reference for exact matching to your query.
    
    Specified by:
    
    primaryObjectReferenceTypeIn in interface TaskQuery
    
    Parameters:
    
    types - the types your primary object reference
    
    Returns:
    
    the query
  - primaryObjectReferenceTypeNotIn
```
public TaskQuery primaryObjectReferenceTypeNotIn(String... types)
```
    Description copied from interface: TaskQuery
    
    Exclude the types of the primary object reference for exact matching from your query.
    
    Specified by:
    
    primaryObjectReferenceTypeNotIn in interface TaskQuery
    
    Parameters:
    
    types - the types your primary object reference
    
    Returns:
    
    the query
  - primaryObjectReferenceTypeLike
```
public TaskQuery primaryObjectReferenceTypeLike(String... types)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    primaryObjectReferenceTypeLike in interface TaskQuery
    
    Parameters:
    
    types - the types of your primary object reference
    
    Returns:
    
    the query
  - primaryObjectReferenceTypeNotLike
```
public TaskQuery primaryObjectReferenceTypeNotLike(String... types)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    primaryObjectReferenceTypeNotLike in interface TaskQuery
    
    Parameters:
    
    types - the types of your primary object reference
    
    Returns:
    
    the query
  - orderByPrimaryObjectReferenceType
```
public TaskQuery orderByPrimaryObjectReferenceType(BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    This method sorts the query result according to the type of the primary object reference.
    
    Specified by:
    
    orderByPrimaryObjectReferenceType in interface TaskQuery
    
    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
```
public TaskQuery primaryObjectReferenceValueIn(String... values)
```
    Description copied from interface: TaskQuery
    
    Add the values of the primary object reference for exact matching to your query.
    
    Specified by:
    
    primaryObjectReferenceValueIn in interface TaskQuery
    
    Parameters:
    
    values - the values of your primary object reference
    
    Returns:
    
    the query
  - primaryObjectReferenceValueNotIn
```
public TaskQuery primaryObjectReferenceValueNotIn(String... values)
```
    Description copied from interface: TaskQuery
    
    Exclude the values of the primary object reference for exact matching from your query.
    
    Specified by:
    
    primaryObjectReferenceValueNotIn in interface TaskQuery
    
    Parameters:
    
    values - the values of your primary object reference
    
    Returns:
    
    the query
  - primaryObjectReferenceValueLike
```
public TaskQuery primaryObjectReferenceValueLike(String... values)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    primaryObjectReferenceValueLike in interface TaskQuery
    
    Parameters:
    
    values - the values of your primary object reference
    
    Returns:
    
    the query
  - primaryObjectReferenceValueNotLike
```
public TaskQuery primaryObjectReferenceValueNotLike(String... values)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    primaryObjectReferenceValueNotLike in interface TaskQuery
    
    Parameters:
    
    values - the values of your primary object reference
    
    Returns:
    
    the query
  - orderByPrimaryObjectReferenceValue
```
public TaskQuery orderByPrimaryObjectReferenceValue(BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    This method sorts the query result according to the value of the primary object reference.
    
    Specified by:
    
    orderByPrimaryObjectReferenceValue in interface TaskQuery
    
    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
```
public TaskQuery readEquals(Boolean isRead)
```
    Description copied from interface: TaskQuery
    
    Add the isRead flag to the query.
    
    Specified by:
    
    readEquals in interface TaskQuery
    
    Parameters:
    
    isRead - as Boolean. If null, it won't be integrated into the statement. You have to set false.
    
    Returns:
    
    the query
  - transferredEquals
```
public TaskQuery transferredEquals(Boolean isTransferred)
```
    Description copied from interface: TaskQuery
    
    Add the isTransferred flag to the query.
    
    Specified by:
    
    transferredEquals in interface TaskQuery
    
    Parameters:
    
    isTransferred - as Boolean. If null, it won't be integrated into the statement. You have to set false.
    
    Returns:
    
    the query
  - attachmentClassificationIdIn
```
public TaskQuery attachmentClassificationIdIn(String... attachmentClassificationId)
```
    Description copied from interface: TaskQuery
    
    Add the attachment classification Ids for exact matching to your query.
    
    Specified by:
    
    attachmentClassificationIdIn in interface TaskQuery
    
    Parameters:
    
    attachmentClassificationId - the attachmentClassificationId values of the searched for tasks
    
    Returns:
    
    the query
  - attachmentClassificationIdNotIn
```
public TaskQuery attachmentClassificationIdNotIn(String... attachmentClassificationId)
```
    Description copied from interface: TaskQuery
    
    Exclude the attachment classification Ids for exact matching from your query.
    
    Specified by:
    
    attachmentClassificationIdNotIn in interface TaskQuery
    
    Parameters:
    
    attachmentClassificationId - the attachmentClassificationId values of the searched for tasks
    
    Returns:
    
    the query
  - orderByAttachmentClassificationId
```
public TaskQuery orderByAttachmentClassificationId(BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    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.)
    
    Specified by:
    
    orderByAttachmentClassificationId in interface TaskQuery
    
    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
```
public TaskQuery attachmentClassificationKeyIn(String... attachmentClassificationKeys)
```
    Description copied from interface: TaskQuery
    
    Add the attachment classification keys for exact matching to your query.
    
    Specified by:
    
    attachmentClassificationKeyIn in interface TaskQuery
    
    Parameters:
    
    attachmentClassificationKeys - the attachmentClassificationKeys values of the searched for tasks
    
    Returns:
    
    the query
  - attachmentClassificationKeyNotIn
```
public TaskQuery attachmentClassificationKeyNotIn(String... attachmentClassificationKeys)
```
    Description copied from interface: TaskQuery
    
    Exclude the attachment classification keys for exact matching from your query.
    
    Specified by:
    
    attachmentClassificationKeyNotIn in interface TaskQuery
    
    Parameters:
    
    attachmentClassificationKeys - the attachmentClassificationKeys values of the searched for tasks
    
    Returns:
    
    the query
  - attachmentClassificationKeyLike
```
public TaskQuery attachmentClassificationKeyLike(String... attachmentClassificationKey)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    attachmentClassificationKeyLike in interface TaskQuery
    
    Parameters:
    
    attachmentClassificationKey - the attachmentClassificationKeys values of the searched for tasks
    
    Returns:
    
    the query
  - attachmentClassificationKeyNotLike
```
public TaskQuery attachmentClassificationKeyNotLike(String... attachmentClassificationKey)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    attachmentClassificationKeyNotLike in interface TaskQuery
    
    Parameters:
    
    attachmentClassificationKey - the attachmentClassificationKeys values of the searched for tasks
    
    Returns:
    
    the query
  - orderByAttachmentClassificationKey
```
public TaskQuery orderByAttachmentClassificationKey(BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    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.)
    
    Specified by:
    
    orderByAttachmentClassificationKey in interface TaskQuery
    
    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
```
public TaskQuery attachmentClassificationNameIn(String... attachmentClassificationName)
```
    Description copied from interface: TaskQuery
    
    Add the attachment classification names for exact matching to your query.
    
    Specified by:
    
    attachmentClassificationNameIn in interface TaskQuery
    
    Parameters:
    
    attachmentClassificationName - the attachmentClassificationName values of the searched for tasks
    
    Returns:
    
    the query
  - attachmentClassificationNameNotIn
```
public TaskQuery attachmentClassificationNameNotIn(String... attachmentClassificationName)
```
    Description copied from interface: TaskQuery
    
    Exclude the attachment classification names for exact matching from your query.
    
    Specified by:
    
    attachmentClassificationNameNotIn in interface TaskQuery
    
    Parameters:
    
    attachmentClassificationName - the attachmentClassificationName values of the searched for tasks
    
    Returns:
    
    the query
  - attachmentClassificationNameLike
```
public TaskQuery attachmentClassificationNameLike(String... attachmentClassificationName)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    attachmentClassificationNameLike in interface TaskQuery
    
    Parameters:
    
    attachmentClassificationName - the attachmentClassificationName values of the searched-for tasks
    
    Returns:
    
    the query
  - attachmentClassificationNameNotLike
```
public TaskQuery attachmentClassificationNameNotLike(String... attachmentClassificationName)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    attachmentClassificationNameNotLike in interface TaskQuery
    
    Parameters:
    
    attachmentClassificationName - the attachmentClassificationName values of the searched-for tasks
    
    Returns:
    
    the query
  - orderByAttachmentClassificationName
```
public TaskQuery orderByAttachmentClassificationName(BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    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.)
    
    Specified by:
    
    orderByAttachmentClassificationName in interface TaskQuery
    
    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
```
public TaskQuery attachmentChannelIn(String... attachmentChannel)
```
    Description copied from interface: TaskQuery
    
    Add the values of attachment channel for exact matching to your query.
    
    Specified by:
    
    attachmentChannelIn in interface TaskQuery
    
    Parameters:
    
    attachmentChannel - the attachmentChannel values of the searched for tasks
    
    Returns:
    
    the query
  - attachmentChannelNotIn
```
public TaskQuery attachmentChannelNotIn(String... attachmentChannel)
```
    Description copied from interface: TaskQuery
    
    Exclude the values of attachment channel for exact matching from your query.
    
    Specified by:
    
    attachmentChannelNotIn in interface TaskQuery
    
    Parameters:
    
    attachmentChannel - the attachmentChannel values of the searched for tasks
    
    Returns:
    
    the query
  - attachmentChannelLike
```
public TaskQuery attachmentChannelLike(String... attachmentChannel)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    attachmentChannelLike in interface TaskQuery
    
    Parameters:
    
    attachmentChannel - the attachmentChannel values of the searched-for tasks
    
    Returns:
    
    the query
  - attachmentChannelNotLike
```
public TaskQuery attachmentChannelNotLike(String... attachmentChannel)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    attachmentChannelNotLike in interface TaskQuery
    
    Parameters:
    
    attachmentChannel - the attachmentChannel values of the searched-for tasks
    
    Returns:
    
    the query
  - orderByAttachmentChannel
```
public TaskQuery orderByAttachmentChannel(BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    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.)
    
    Specified by:
    
    orderByAttachmentChannel in interface TaskQuery
    
    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
```
public TaskQuery attachmentReferenceValueIn(String... referenceValue)
```
    Description copied from interface: TaskQuery
    
    Add the values of reference values for exact matching to your query.
    
    Specified by:
    
    attachmentReferenceValueIn in interface TaskQuery
    
    Parameters:
    
    referenceValue - the referenceValue values of the searched for tasks
    
    Returns:
    
    the query
  - attachmentReferenceValueNotIn
```
public TaskQuery attachmentReferenceValueNotIn(String... referenceValue)
```
    Description copied from interface: TaskQuery
    
    Exclude the values of reference values for exact matching from your query.
    
    Specified by:
    
    attachmentReferenceValueNotIn in interface TaskQuery
    
    Parameters:
    
    referenceValue - the referenceValue values of the searched for tasks
    
    Returns:
    
    the query
  - attachmentReferenceValueLike
```
public TaskQuery attachmentReferenceValueLike(String... referenceValue)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    attachmentReferenceValueLike in interface TaskQuery
    
    Parameters:
    
    referenceValue - the referenceValue values of the searched-for tasks
    
    Returns:
    
    the query
  - attachmentReferenceValueNotLike
```
public TaskQuery attachmentReferenceValueNotLike(String... referenceValue)
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    attachmentReferenceValueNotLike in interface TaskQuery
    
    Parameters:
    
    referenceValue - the referenceValue values of the searched-for tasks
    
    Returns:
    
    the query
  - orderByAttachmentReference
```
public TaskQuery orderByAttachmentReference(BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    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.)
    
    Specified by:
    
    orderByAttachmentReference in interface TaskQuery
    
    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
```
public TaskQuery attachmentReceivedWithin(TimeInterval... receivedIn)
```
    Description copied from interface: TaskQuery
    
    Add your received-dates to your query.
    
    Specified by:
    
    attachmentReceivedWithin in interface TaskQuery
    
    Parameters:
    
    receivedIn - the TimeInterval within which the searched-for tasks attachment were received the last time.
    
    Returns:
    
    the query
  - attachmentNotReceivedWithin
```
public TaskQuery attachmentNotReceivedWithin(TimeInterval... receivedNotIn)
```
    Description copied from interface: TaskQuery
    
    Exclude the received-dates from your query.
    
    Specified by:
    
    attachmentNotReceivedWithin in interface TaskQuery
    
    Parameters:
    
    receivedNotIn - the TimeInterval within which the searched-for tasks attachment weren't received the last time.
    
    Returns:
    
    the query
  - orderByAttachmentReceived
```
public TaskQuery orderByAttachmentReceived(BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    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.)
    
    Specified by:
    
    orderByAttachmentReceived in interface TaskQuery
    
    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
  - getOwnerLongNameIn
```
public String[] getOwnerLongNameIn()
```
  - getOwnerLongNameNotIn
```
public String[] getOwnerLongNameNotIn()
```
  - getOwnerLongNameLike
```
public String[] getOwnerLongNameLike()
```
  - getOwnerLongNameNotLike
```
public String[] getOwnerLongNameNotLike()
```
  - customAttributeIn
```
public TaskQuery customAttributeIn(TaskCustomField customField,
                                   String... strings)
                            throws InvalidArgumentException
```
    Description copied from interface: TaskQuery
    
    Add the values of custom attributes for exact matching to your query.
    
    Specified by:
    
    customAttributeIn in interface TaskQuery
    
    Parameters:
    
    customField - identifies which custom attribute is affected.
    
    strings - the customField values of the searched for tasks
    
    Returns:
    
    the query
    
    Throws:
    
    InvalidArgumentException - if searchArguments are not given
  - customAttributeNotIn
```
public TaskQuery customAttributeNotIn(TaskCustomField customField,
                                      String... strings)
                               throws InvalidArgumentException
```
    Description copied from interface: TaskQuery
    
    Exclude these values of custom attributes from your query.
    
    Specified by:
    
    customAttributeNotIn in interface TaskQuery
    
    Parameters:
    
    customField - identifies which custom attribute is affected.
    
    strings - the customField values of the searched for tasks
    
    Returns:
    
    the query
    
    Throws:
    
    InvalidArgumentException - if searchArguments are not given
  - customAttributeLike
```
public TaskQuery customAttributeLike(TaskCustomField customField,
                                     String... strings)
                              throws InvalidArgumentException
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    customAttributeLike in interface TaskQuery
    
    Parameters:
    
    customField - identifies which custom attribute is affected.
    
    strings - the customField values of the searched for tasks
    
    Returns:
    
    the query
    
    Throws:
    
    InvalidArgumentException - if searchArguments is not given
  - customAttributeNotLike
```
public TaskQuery customAttributeNotLike(TaskCustomField customField,
                                        String... strings)
                                 throws InvalidArgumentException
```
    Description copied from interface: TaskQuery
    
    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.
    
    Specified by:
    
    customAttributeNotLike in interface TaskQuery
    
    Parameters:
    
    customField - identifies which custom attribute is affected.
    
    strings - the customField values of the searched for tasks
    
    Returns:
    
    the query
    
    Throws:
    
    InvalidArgumentException - if searchArguments is not given
  - orderByCustomAttribute
```
public TaskQuery orderByCustomAttribute(TaskCustomField customField,
                                        BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    This method sorts the query result according to the value of a custom field.
    
    Specified by:
    
    orderByCustomAttribute in interface TaskQuery
    
    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
```
public TaskQuery callbackStateIn(CallbackState... states)
```
    Description copied from interface: TaskQuery
    
    Add your callbackState to your query.
    
    Specified by:
    
    callbackStateIn in interface TaskQuery
    
    Parameters:
    
    states - the callback states as CallbackState
    
    Returns:
    
    the query
  - callbackStateNotIn
```
public TaskQuery callbackStateNotIn(CallbackState... states)
```
    Description copied from interface: TaskQuery
    
    Exclude the callbackState from your query.
    
    Specified by:
    
    callbackStateNotIn in interface TaskQuery
    
    Parameters:
    
    states - the callback states as CallbackState
    
    Returns:
    
    the query
  - wildcardSearchValueLike
```
public TaskQuery wildcardSearchValueLike(String wildcardSearchValue)
```
    Description copied from interface: TaskQuery
    
    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
    
    Specified by:
    
    wildcardSearchValueLike in interface TaskQuery
    
    Parameters:
    
    wildcardSearchValue - the wildcard search value
    
    Returns:
    
    the query
  - wildcardSearchFieldsIn
```
public TaskQuery wildcardSearchFieldsIn(WildcardSearchField... wildcardSearchFields)
```
    Description copied from interface: TaskQuery
    
    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
    
    Specified by:
    
    wildcardSearchFieldsIn in interface TaskQuery
    
    Parameters:
    
    wildcardSearchFields - the Task fields of your wildcard search
    
    Returns:
    
    the query
  - createObjectReferenceQuery
```
public ObjectReferenceQuery createObjectReferenceQuery()
```
    Description copied from interface: TaskQuery
    
    This method provides a query builder for quering the database.
    
    Specified by:
    
    createObjectReferenceQuery in interface TaskQuery
    
    Returns:
    
    a ObjectReferenceQuery
  - orderByDomain
```
public TaskQuery orderByDomain(BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    This method sorts the query result according to the domain.
    
    Specified by:
    
    orderByDomain in interface TaskQuery
    
    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
```
public TaskQuery orderByWorkbasketKey(BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    This method sorts the query result according to the workbasket key.
    
    Specified by:
    
    orderByWorkbasketKey in interface TaskQuery
    
    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
```
public TaskQuery orderByWorkbasketName(BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    This method sorts the query result according to the workbasket name of the tasks.
    
    Specified by:
    
    orderByWorkbasketName in interface TaskQuery
    
    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
  - orderByOwnerLongName
```
public TaskQuery orderByOwnerLongName(BaseQuery.SortDirection sortDirection)
```
    Description copied from interface: TaskQuery
    
    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.)
    
    Specified by:
    
    orderByOwnerLongName in interface TaskQuery
    
    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
  - list
```
public List<TaskSummary> list()
```
    Specified by:
    
    list in interface BaseQuery<TaskSummary,TaskQueryColumnName>
  - list
```
public List<TaskSummary> list(int offset,
                              int limit)
```
    Specified by:
    
    list in interface BaseQuery<TaskSummary,TaskQueryColumnName>
  - listValues
```
public List<String> listValues(TaskQueryColumnName columnName,
                               BaseQuery.SortDirection sortDirection)
```
    Specified by:
    
    listValues in interface BaseQuery<TaskSummary,TaskQueryColumnName>
  - single
```
public TaskSummary single()
```
    Specified by:
    
    single in interface BaseQuery<TaskSummary,TaskQueryColumnName>
  - count
```
public long count()
```
    Specified by:
    
    count in interface BaseQuery<TaskSummary,TaskQueryColumnName>
  - selectAndClaimEquals
```
public TaskQuery selectAndClaimEquals(boolean selectAndClaim)
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class TaskQueryImpl

Nested Class Summary

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

Method Summary

Methods inherited from class java.lang.Object

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

businessProcessIdIn

businessProcessIdNotIn

businessProcessIdLike

businessProcessIdNotLike

orderByBusinessProcessId