# -*- coding: utf-8 -*-
# **********************************************************************
#
# Copyright (c) 2003-2016 ZeroC, Inc. All rights reserved.
#
# This copy of Ice is licensed to you under the terms described in the
# ICE_LICENSE file included in this distribution.
#
# **********************************************************************
#
# Ice version 3.6.3
#
# <auto-generated>
#
# Generated from file `Search.ice'
#
# Warning: do not edit this file.
#
# </auto-generated>
#

from sys import version_info as _version_info_
import Ice, IcePy
import omero_ServicesF_ice
import omero_System_ice
import omero_Collections_ice

# Included module Ice
_M_Ice = Ice.openModule('Ice')

# Included module Glacier2
_M_Glacier2 = Ice.openModule('Glacier2')

# Included module omero
_M_omero = Ice.openModule('omero')

# Included module omero.model
_M_omero.model = Ice.openModule('omero.model')

# Included module omero.sys
_M_omero.sys = Ice.openModule('omero.sys')

# Included module omero.api
_M_omero.api = Ice.openModule('omero.api')

# Included module omero.grid
_M_omero.grid = Ice.openModule('omero.grid')

# Start of module omero
__name__ = 'omero'

# Start of module omero.api
__name__ = 'omero.api'

if 'Search' not in _M_omero.api.__dict__:
    _M_omero.api.Search = Ice.createTempClass()
    class Search(_M_omero.api.StatefulServiceInterface):
        """
        See Search.html
        """
        def __init__(self):
            if Ice.getType(self) == _M_omero.api.Search:
                raise RuntimeError('omero.api.Search is an abstract class')

        def ice_ids(self, current=None):
            return ('::Ice::Object', '::omero::api::Search', '::omero::api::ServiceInterface', '::omero::api::StatefulServiceInterface')

        def ice_id(self, current=None):
            return '::omero::api::Search'

        def ice_staticId():
            return '::omero::api::Search'
        ice_staticId = staticmethod(ice_staticId)

        def activeQueries_async(self, _cb, current=None):
            pass

        def setBatchSize_async(self, _cb, size, current=None):
            pass

        def getBatchSize_async(self, _cb, current=None):
            pass

        def setMergedBatches_async(self, _cb, merge, current=None):
            pass

        def isMergedBatches_async(self, _cb, current=None):
            pass

        def setCaseSentivice_async(self, _cb, caseSensitive, current=None):
            pass

        def isCaseSensitive_async(self, _cb, current=None):
            pass

        def setUseProjections_async(self, _cb, useProjections, current=None):
            pass

        def isUseProjections_async(self, _cb, current=None):
            pass

        def setReturnUnloaded_async(self, _cb, returnUnloaded, current=None):
            pass

        def isReturnUnloaded_async(self, _cb, current=None):
            pass

        def setAllowLeadingWildcard_async(self, _cb, allowLeadingWildcard, current=None):
            pass

        def isAllowLeadingWildcard_async(self, _cb, current=None):
            pass

        def onlyType_async(self, _cb, klass, current=None):
            pass

        def onlyTypes_async(self, _cb, classes, current=None):
            pass

        def allTypes_async(self, _cb, current=None):
            pass

        def onlyIds_async(self, _cb, ids, current=None):
            pass

        def onlyOwnedBy_async(self, _cb, d, current=None):
            pass

        def notOwnedBy_async(self, _cb, d, current=None):
            pass

        def onlyCreatedBetween_async(self, _cb, start, stop, current=None):
            pass

        def onlyModifiedBetween_async(self, _cb, start, stop, current=None):
            pass

        def onlyAnnotatedBetween_async(self, _cb, start, stop, current=None):
            pass

        def onlyAnnotatedBy_async(self, _cb, d, current=None):
            pass

        def notAnnotatedBy_async(self, _cb, d, current=None):
            pass

        def onlyAnnotatedWith_async(self, _cb, classes, current=None):
            pass

        def addOrderByAsc_async(self, _cb, path, current=None):
            pass

        def addOrderByDesc_async(self, _cb, path, current=None):
            pass

        def unordered_async(self, _cb, current=None):
            pass

        def fetchAnnotations_async(self, _cb, classes, current=None):
            pass

        def fetchAlso_async(self, _cb, fetches, current=None):
            pass

        def resetDefaults_async(self, _cb, current=None):
            pass

        def byGroupForTags_async(self, _cb, group, current=None):
            pass

        def byTagForGroups_async(self, _cb, tag, current=None):
            pass

        def byFullText_async(self, _cb, query, current=None):
            pass

        def byLuceneQueryBuilder_async(self, _cb, fields, _from, to, dateType, query, current=None):
            pass

        def bySimilarTerms_async(self, _cb, terms, current=None):
            pass

        def byHqlQuery_async(self, _cb, query, params, current=None):
            pass

        def bySomeMustNone_async(self, _cb, some, must, none, current=None):
            pass

        def byAnnotatedWith_async(self, _cb, examples, current=None):
            pass

        def clearQueries_async(self, _cb, current=None):
            pass

        def and_async(self, _cb, current=None):
            pass

        def or_async(self, _cb, current=None):
            pass

        def not_async(self, _cb, current=None):
            pass

        def hasNext_async(self, _cb, current=None):
            pass

        def next_async(self, _cb, current=None):
            pass

        def results_async(self, _cb, current=None):
            pass

        def currentMetadata_async(self, _cb, current=None):
            pass

        def currentMetadataList_async(self, _cb, current=None):
            pass

        def remove_async(self, _cb, current=None):
            pass

        def __str__(self):
            return IcePy.stringify(self, _M_omero.api._t_Search)

        __repr__ = __str__

    _M_omero.api.SearchPrx = Ice.createTempClass()
    class SearchPrx(_M_omero.api.StatefulServiceInterfacePrx):

        def activeQueries(self, _ctx=None):
            return _M_omero.api.Search._op_activeQueries.invoke(self, ((), _ctx))

        def begin_activeQueries(self, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_activeQueries.begin(self, ((), _response, _ex, _sent, _ctx))

        def end_activeQueries(self, _r):
            return _M_omero.api.Search._op_activeQueries.end(self, _r)

        def setBatchSize(self, size, _ctx=None):
            return _M_omero.api.Search._op_setBatchSize.invoke(self, ((size, ), _ctx))

        def begin_setBatchSize(self, size, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_setBatchSize.begin(self, ((size, ), _response, _ex, _sent, _ctx))

        def end_setBatchSize(self, _r):
            return _M_omero.api.Search._op_setBatchSize.end(self, _r)

        def getBatchSize(self, _ctx=None):
            return _M_omero.api.Search._op_getBatchSize.invoke(self, ((), _ctx))

        def begin_getBatchSize(self, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_getBatchSize.begin(self, ((), _response, _ex, _sent, _ctx))

        def end_getBatchSize(self, _r):
            return _M_omero.api.Search._op_getBatchSize.end(self, _r)

        def setMergedBatches(self, merge, _ctx=None):
            return _M_omero.api.Search._op_setMergedBatches.invoke(self, ((merge, ), _ctx))

        def begin_setMergedBatches(self, merge, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_setMergedBatches.begin(self, ((merge, ), _response, _ex, _sent, _ctx))

        def end_setMergedBatches(self, _r):
            return _M_omero.api.Search._op_setMergedBatches.end(self, _r)

        def isMergedBatches(self, _ctx=None):
            return _M_omero.api.Search._op_isMergedBatches.invoke(self, ((), _ctx))

        def begin_isMergedBatches(self, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_isMergedBatches.begin(self, ((), _response, _ex, _sent, _ctx))

        def end_isMergedBatches(self, _r):
            return _M_omero.api.Search._op_isMergedBatches.end(self, _r)

        def setCaseSentivice(self, caseSensitive, _ctx=None):
            return _M_omero.api.Search._op_setCaseSentivice.invoke(self, ((caseSensitive, ), _ctx))

        def begin_setCaseSentivice(self, caseSensitive, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_setCaseSentivice.begin(self, ((caseSensitive, ), _response, _ex, _sent, _ctx))

        def end_setCaseSentivice(self, _r):
            return _M_omero.api.Search._op_setCaseSentivice.end(self, _r)

        def isCaseSensitive(self, _ctx=None):
            return _M_omero.api.Search._op_isCaseSensitive.invoke(self, ((), _ctx))

        def begin_isCaseSensitive(self, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_isCaseSensitive.begin(self, ((), _response, _ex, _sent, _ctx))

        def end_isCaseSensitive(self, _r):
            return _M_omero.api.Search._op_isCaseSensitive.end(self, _r)

        def setUseProjections(self, useProjections, _ctx=None):
            return _M_omero.api.Search._op_setUseProjections.invoke(self, ((useProjections, ), _ctx))

        def begin_setUseProjections(self, useProjections, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_setUseProjections.begin(self, ((useProjections, ), _response, _ex, _sent, _ctx))

        def end_setUseProjections(self, _r):
            return _M_omero.api.Search._op_setUseProjections.end(self, _r)

        def isUseProjections(self, _ctx=None):
            return _M_omero.api.Search._op_isUseProjections.invoke(self, ((), _ctx))

        def begin_isUseProjections(self, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_isUseProjections.begin(self, ((), _response, _ex, _sent, _ctx))

        def end_isUseProjections(self, _r):
            return _M_omero.api.Search._op_isUseProjections.end(self, _r)

        def setReturnUnloaded(self, returnUnloaded, _ctx=None):
            return _M_omero.api.Search._op_setReturnUnloaded.invoke(self, ((returnUnloaded, ), _ctx))

        def begin_setReturnUnloaded(self, returnUnloaded, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_setReturnUnloaded.begin(self, ((returnUnloaded, ), _response, _ex, _sent, _ctx))

        def end_setReturnUnloaded(self, _r):
            return _M_omero.api.Search._op_setReturnUnloaded.end(self, _r)

        def isReturnUnloaded(self, _ctx=None):
            return _M_omero.api.Search._op_isReturnUnloaded.invoke(self, ((), _ctx))

        def begin_isReturnUnloaded(self, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_isReturnUnloaded.begin(self, ((), _response, _ex, _sent, _ctx))

        def end_isReturnUnloaded(self, _r):
            return _M_omero.api.Search._op_isReturnUnloaded.end(self, _r)

        def setAllowLeadingWildcard(self, allowLeadingWildcard, _ctx=None):
            return _M_omero.api.Search._op_setAllowLeadingWildcard.invoke(self, ((allowLeadingWildcard, ), _ctx))

        def begin_setAllowLeadingWildcard(self, allowLeadingWildcard, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_setAllowLeadingWildcard.begin(self, ((allowLeadingWildcard, ), _response, _ex, _sent, _ctx))

        def end_setAllowLeadingWildcard(self, _r):
            return _M_omero.api.Search._op_setAllowLeadingWildcard.end(self, _r)

        def isAllowLeadingWildcard(self, _ctx=None):
            return _M_omero.api.Search._op_isAllowLeadingWildcard.invoke(self, ((), _ctx))

        def begin_isAllowLeadingWildcard(self, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_isAllowLeadingWildcard.begin(self, ((), _response, _ex, _sent, _ctx))

        def end_isAllowLeadingWildcard(self, _r):
            return _M_omero.api.Search._op_isAllowLeadingWildcard.end(self, _r)

        def onlyType(self, klass, _ctx=None):
            return _M_omero.api.Search._op_onlyType.invoke(self, ((klass, ), _ctx))

        def begin_onlyType(self, klass, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_onlyType.begin(self, ((klass, ), _response, _ex, _sent, _ctx))

        def end_onlyType(self, _r):
            return _M_omero.api.Search._op_onlyType.end(self, _r)

        def onlyTypes(self, classes, _ctx=None):
            return _M_omero.api.Search._op_onlyTypes.invoke(self, ((classes, ), _ctx))

        def begin_onlyTypes(self, classes, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_onlyTypes.begin(self, ((classes, ), _response, _ex, _sent, _ctx))

        def end_onlyTypes(self, _r):
            return _M_omero.api.Search._op_onlyTypes.end(self, _r)

        def allTypes(self, _ctx=None):
            return _M_omero.api.Search._op_allTypes.invoke(self, ((), _ctx))

        def begin_allTypes(self, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_allTypes.begin(self, ((), _response, _ex, _sent, _ctx))

        def end_allTypes(self, _r):
            return _M_omero.api.Search._op_allTypes.end(self, _r)

        def onlyIds(self, ids, _ctx=None):
            return _M_omero.api.Search._op_onlyIds.invoke(self, ((ids, ), _ctx))

        def begin_onlyIds(self, ids, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_onlyIds.begin(self, ((ids, ), _response, _ex, _sent, _ctx))

        def end_onlyIds(self, _r):
            return _M_omero.api.Search._op_onlyIds.end(self, _r)

        def onlyOwnedBy(self, d, _ctx=None):
            return _M_omero.api.Search._op_onlyOwnedBy.invoke(self, ((d, ), _ctx))

        def begin_onlyOwnedBy(self, d, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_onlyOwnedBy.begin(self, ((d, ), _response, _ex, _sent, _ctx))

        def end_onlyOwnedBy(self, _r):
            return _M_omero.api.Search._op_onlyOwnedBy.end(self, _r)

        def notOwnedBy(self, d, _ctx=None):
            return _M_omero.api.Search._op_notOwnedBy.invoke(self, ((d, ), _ctx))

        def begin_notOwnedBy(self, d, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_notOwnedBy.begin(self, ((d, ), _response, _ex, _sent, _ctx))

        def end_notOwnedBy(self, _r):
            return _M_omero.api.Search._op_notOwnedBy.end(self, _r)

        def onlyCreatedBetween(self, start, stop, _ctx=None):
            return _M_omero.api.Search._op_onlyCreatedBetween.invoke(self, ((start, stop), _ctx))

        def begin_onlyCreatedBetween(self, start, stop, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_onlyCreatedBetween.begin(self, ((start, stop), _response, _ex, _sent, _ctx))

        def end_onlyCreatedBetween(self, _r):
            return _M_omero.api.Search._op_onlyCreatedBetween.end(self, _r)

        def onlyModifiedBetween(self, start, stop, _ctx=None):
            return _M_omero.api.Search._op_onlyModifiedBetween.invoke(self, ((start, stop), _ctx))

        def begin_onlyModifiedBetween(self, start, stop, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_onlyModifiedBetween.begin(self, ((start, stop), _response, _ex, _sent, _ctx))

        def end_onlyModifiedBetween(self, _r):
            return _M_omero.api.Search._op_onlyModifiedBetween.end(self, _r)

        def onlyAnnotatedBetween(self, start, stop, _ctx=None):
            return _M_omero.api.Search._op_onlyAnnotatedBetween.invoke(self, ((start, stop), _ctx))

        def begin_onlyAnnotatedBetween(self, start, stop, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_onlyAnnotatedBetween.begin(self, ((start, stop), _response, _ex, _sent, _ctx))

        def end_onlyAnnotatedBetween(self, _r):
            return _M_omero.api.Search._op_onlyAnnotatedBetween.end(self, _r)

        def onlyAnnotatedBy(self, d, _ctx=None):
            return _M_omero.api.Search._op_onlyAnnotatedBy.invoke(self, ((d, ), _ctx))

        def begin_onlyAnnotatedBy(self, d, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_onlyAnnotatedBy.begin(self, ((d, ), _response, _ex, _sent, _ctx))

        def end_onlyAnnotatedBy(self, _r):
            return _M_omero.api.Search._op_onlyAnnotatedBy.end(self, _r)

        def notAnnotatedBy(self, d, _ctx=None):
            return _M_omero.api.Search._op_notAnnotatedBy.invoke(self, ((d, ), _ctx))

        def begin_notAnnotatedBy(self, d, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_notAnnotatedBy.begin(self, ((d, ), _response, _ex, _sent, _ctx))

        def end_notAnnotatedBy(self, _r):
            return _M_omero.api.Search._op_notAnnotatedBy.end(self, _r)

        def onlyAnnotatedWith(self, classes, _ctx=None):
            return _M_omero.api.Search._op_onlyAnnotatedWith.invoke(self, ((classes, ), _ctx))

        def begin_onlyAnnotatedWith(self, classes, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_onlyAnnotatedWith.begin(self, ((classes, ), _response, _ex, _sent, _ctx))

        def end_onlyAnnotatedWith(self, _r):
            return _M_omero.api.Search._op_onlyAnnotatedWith.end(self, _r)

        def addOrderByAsc(self, path, _ctx=None):
            return _M_omero.api.Search._op_addOrderByAsc.invoke(self, ((path, ), _ctx))

        def begin_addOrderByAsc(self, path, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_addOrderByAsc.begin(self, ((path, ), _response, _ex, _sent, _ctx))

        def end_addOrderByAsc(self, _r):
            return _M_omero.api.Search._op_addOrderByAsc.end(self, _r)

        def addOrderByDesc(self, path, _ctx=None):
            return _M_omero.api.Search._op_addOrderByDesc.invoke(self, ((path, ), _ctx))

        def begin_addOrderByDesc(self, path, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_addOrderByDesc.begin(self, ((path, ), _response, _ex, _sent, _ctx))

        def end_addOrderByDesc(self, _r):
            return _M_omero.api.Search._op_addOrderByDesc.end(self, _r)

        def unordered(self, _ctx=None):
            return _M_omero.api.Search._op_unordered.invoke(self, ((), _ctx))

        def begin_unordered(self, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_unordered.begin(self, ((), _response, _ex, _sent, _ctx))

        def end_unordered(self, _r):
            return _M_omero.api.Search._op_unordered.end(self, _r)

        def fetchAnnotations(self, classes, _ctx=None):
            return _M_omero.api.Search._op_fetchAnnotations.invoke(self, ((classes, ), _ctx))

        def begin_fetchAnnotations(self, classes, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_fetchAnnotations.begin(self, ((classes, ), _response, _ex, _sent, _ctx))

        def end_fetchAnnotations(self, _r):
            return _M_omero.api.Search._op_fetchAnnotations.end(self, _r)

        def fetchAlso(self, fetches, _ctx=None):
            return _M_omero.api.Search._op_fetchAlso.invoke(self, ((fetches, ), _ctx))

        def begin_fetchAlso(self, fetches, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_fetchAlso.begin(self, ((fetches, ), _response, _ex, _sent, _ctx))

        def end_fetchAlso(self, _r):
            return _M_omero.api.Search._op_fetchAlso.end(self, _r)

        def resetDefaults(self, _ctx=None):
            return _M_omero.api.Search._op_resetDefaults.invoke(self, ((), _ctx))

        def begin_resetDefaults(self, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_resetDefaults.begin(self, ((), _response, _ex, _sent, _ctx))

        def end_resetDefaults(self, _r):
            return _M_omero.api.Search._op_resetDefaults.end(self, _r)

        def byGroupForTags(self, group, _ctx=None):
            return _M_omero.api.Search._op_byGroupForTags.invoke(self, ((group, ), _ctx))

        def begin_byGroupForTags(self, group, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_byGroupForTags.begin(self, ((group, ), _response, _ex, _sent, _ctx))

        def end_byGroupForTags(self, _r):
            return _M_omero.api.Search._op_byGroupForTags.end(self, _r)

        def byTagForGroups(self, tag, _ctx=None):
            return _M_omero.api.Search._op_byTagForGroups.invoke(self, ((tag, ), _ctx))

        def begin_byTagForGroups(self, tag, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_byTagForGroups.begin(self, ((tag, ), _response, _ex, _sent, _ctx))

        def end_byTagForGroups(self, _r):
            return _M_omero.api.Search._op_byTagForGroups.end(self, _r)

        def byFullText(self, query, _ctx=None):
            return _M_omero.api.Search._op_byFullText.invoke(self, ((query, ), _ctx))

        def begin_byFullText(self, query, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_byFullText.begin(self, ((query, ), _response, _ex, _sent, _ctx))

        def end_byFullText(self, _r):
            return _M_omero.api.Search._op_byFullText.end(self, _r)

        def byLuceneQueryBuilder(self, fields, _from, to, dateType, query, _ctx=None):
            return _M_omero.api.Search._op_byLuceneQueryBuilder.invoke(self, ((fields, _from, to, dateType, query), _ctx))

        def begin_byLuceneQueryBuilder(self, fields, _from, to, dateType, query, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_byLuceneQueryBuilder.begin(self, ((fields, _from, to, dateType, query), _response, _ex, _sent, _ctx))

        def end_byLuceneQueryBuilder(self, _r):
            return _M_omero.api.Search._op_byLuceneQueryBuilder.end(self, _r)

        def bySimilarTerms(self, terms, _ctx=None):
            return _M_omero.api.Search._op_bySimilarTerms.invoke(self, ((terms, ), _ctx))

        def begin_bySimilarTerms(self, terms, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_bySimilarTerms.begin(self, ((terms, ), _response, _ex, _sent, _ctx))

        def end_bySimilarTerms(self, _r):
            return _M_omero.api.Search._op_bySimilarTerms.end(self, _r)

        def byHqlQuery(self, query, params, _ctx=None):
            return _M_omero.api.Search._op_byHqlQuery.invoke(self, ((query, params), _ctx))

        def begin_byHqlQuery(self, query, params, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_byHqlQuery.begin(self, ((query, params), _response, _ex, _sent, _ctx))

        def end_byHqlQuery(self, _r):
            return _M_omero.api.Search._op_byHqlQuery.end(self, _r)

        def bySomeMustNone(self, some, must, none, _ctx=None):
            return _M_omero.api.Search._op_bySomeMustNone.invoke(self, ((some, must, none), _ctx))

        def begin_bySomeMustNone(self, some, must, none, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_bySomeMustNone.begin(self, ((some, must, none), _response, _ex, _sent, _ctx))

        def end_bySomeMustNone(self, _r):
            return _M_omero.api.Search._op_bySomeMustNone.end(self, _r)

        def byAnnotatedWith(self, examples, _ctx=None):
            return _M_omero.api.Search._op_byAnnotatedWith.invoke(self, ((examples, ), _ctx))

        def begin_byAnnotatedWith(self, examples, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_byAnnotatedWith.begin(self, ((examples, ), _response, _ex, _sent, _ctx))

        def end_byAnnotatedWith(self, _r):
            return _M_omero.api.Search._op_byAnnotatedWith.end(self, _r)

        def clearQueries(self, _ctx=None):
            return _M_omero.api.Search._op_clearQueries.invoke(self, ((), _ctx))

        def begin_clearQueries(self, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_clearQueries.begin(self, ((), _response, _ex, _sent, _ctx))

        def end_clearQueries(self, _r):
            return _M_omero.api.Search._op_clearQueries.end(self, _r)

        def _and(self, _ctx=None):
            return _M_omero.api.Search._op_and.invoke(self, ((), _ctx))

        def begin_and(self, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_and.begin(self, ((), _response, _ex, _sent, _ctx))

        def end_and(self, _r):
            return _M_omero.api.Search._op_and.end(self, _r)

        def _or(self, _ctx=None):
            return _M_omero.api.Search._op_or.invoke(self, ((), _ctx))

        def begin_or(self, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_or.begin(self, ((), _response, _ex, _sent, _ctx))

        def end_or(self, _r):
            return _M_omero.api.Search._op_or.end(self, _r)

        def _not(self, _ctx=None):
            return _M_omero.api.Search._op_not.invoke(self, ((), _ctx))

        def begin_not(self, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_not.begin(self, ((), _response, _ex, _sent, _ctx))

        def end_not(self, _r):
            return _M_omero.api.Search._op_not.end(self, _r)

        def hasNext(self, _ctx=None):
            return _M_omero.api.Search._op_hasNext.invoke(self, ((), _ctx))

        def begin_hasNext(self, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_hasNext.begin(self, ((), _response, _ex, _sent, _ctx))

        def end_hasNext(self, _r):
            return _M_omero.api.Search._op_hasNext.end(self, _r)

        def next(self, _ctx=None):
            return _M_omero.api.Search._op_next.invoke(self, ((), _ctx))

        def begin_next(self, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_next.begin(self, ((), _response, _ex, _sent, _ctx))

        def end_next(self, _r):
            return _M_omero.api.Search._op_next.end(self, _r)

        def results(self, _ctx=None):
            return _M_omero.api.Search._op_results.invoke(self, ((), _ctx))

        def begin_results(self, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_results.begin(self, ((), _response, _ex, _sent, _ctx))

        def end_results(self, _r):
            return _M_omero.api.Search._op_results.end(self, _r)

        def currentMetadata(self, _ctx=None):
            return _M_omero.api.Search._op_currentMetadata.invoke(self, ((), _ctx))

        def begin_currentMetadata(self, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_currentMetadata.begin(self, ((), _response, _ex, _sent, _ctx))

        def end_currentMetadata(self, _r):
            return _M_omero.api.Search._op_currentMetadata.end(self, _r)

        def currentMetadataList(self, _ctx=None):
            return _M_omero.api.Search._op_currentMetadataList.invoke(self, ((), _ctx))

        def begin_currentMetadataList(self, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_currentMetadataList.begin(self, ((), _response, _ex, _sent, _ctx))

        def end_currentMetadataList(self, _r):
            return _M_omero.api.Search._op_currentMetadataList.end(self, _r)

        def remove(self, _ctx=None):
            return _M_omero.api.Search._op_remove.invoke(self, ((), _ctx))

        def begin_remove(self, _response=None, _ex=None, _sent=None, _ctx=None):
            return _M_omero.api.Search._op_remove.begin(self, ((), _response, _ex, _sent, _ctx))

        def end_remove(self, _r):
            return _M_omero.api.Search._op_remove.end(self, _r)

        def checkedCast(proxy, facetOrCtx=None, _ctx=None):
            return _M_omero.api.SearchPrx.ice_checkedCast(proxy, '::omero::api::Search', facetOrCtx, _ctx)
        checkedCast = staticmethod(checkedCast)

        def uncheckedCast(proxy, facet=None):
            return _M_omero.api.SearchPrx.ice_uncheckedCast(proxy, facet)
        uncheckedCast = staticmethod(uncheckedCast)

        def ice_staticId():
            return '::omero::api::Search'
        ice_staticId = staticmethod(ice_staticId)

    _M_omero.api._t_SearchPrx = IcePy.defineProxy('::omero::api::Search', SearchPrx)

    _M_omero.api._t_Search = IcePy.defineClass('::omero::api::Search', Search, -1, (), True, False, None, (_M_omero.api._t_StatefulServiceInterface,), ())
    Search._ice_type = _M_omero.api._t_Search

    Search._op_activeQueries = IcePy.Operation('activeQueries', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, True, None, (), (), (), ((), IcePy._t_int, False, 0), (_M_omero._t_ServerError,))
    Search._op_setBatchSize = IcePy.Operation('setBatchSize', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, True, None, (), (((), IcePy._t_int, False, 0),), (), None, (_M_omero._t_ServerError,))
    Search._op_getBatchSize = IcePy.Operation('getBatchSize', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, True, None, (), (), (), ((), IcePy._t_int, False, 0), (_M_omero._t_ServerError,))
    Search._op_setMergedBatches = IcePy.Operation('setMergedBatches', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, True, None, (), (((), IcePy._t_bool, False, 0),), (), None, (_M_omero._t_ServerError,))
    Search._op_isMergedBatches = IcePy.Operation('isMergedBatches', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, True, None, (), (), (), ((), IcePy._t_bool, False, 0), (_M_omero._t_ServerError,))
    Search._op_setCaseSentivice = IcePy.Operation('setCaseSentivice', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, True, None, (), (((), IcePy._t_bool, False, 0),), (), None, (_M_omero._t_ServerError,))
    Search._op_isCaseSensitive = IcePy.Operation('isCaseSensitive', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, True, None, (), (), (), ((), IcePy._t_bool, False, 0), (_M_omero._t_ServerError,))
    Search._op_setUseProjections = IcePy.Operation('setUseProjections', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, True, None, (), (((), IcePy._t_bool, False, 0),), (), None, (_M_omero._t_ServerError,))
    Search._op_isUseProjections = IcePy.Operation('isUseProjections', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, True, None, (), (), (), ((), IcePy._t_bool, False, 0), (_M_omero._t_ServerError,))
    Search._op_setReturnUnloaded = IcePy.Operation('setReturnUnloaded', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, True, None, (), (((), IcePy._t_bool, False, 0),), (), None, (_M_omero._t_ServerError,))
    Search._op_isReturnUnloaded = IcePy.Operation('isReturnUnloaded', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, True, None, (), (), (), ((), IcePy._t_bool, False, 0), (_M_omero._t_ServerError,))
    Search._op_setAllowLeadingWildcard = IcePy.Operation('setAllowLeadingWildcard', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, True, None, (), (((), IcePy._t_bool, False, 0),), (), None, (_M_omero._t_ServerError,))
    Search._op_isAllowLeadingWildcard = IcePy.Operation('isAllowLeadingWildcard', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, True, None, (), (), (), ((), IcePy._t_bool, False, 0), (_M_omero._t_ServerError,))
    Search._op_onlyType = IcePy.Operation('onlyType', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, None, (), (((), IcePy._t_string, False, 0),), (), None, (_M_omero._t_ServerError,))
    Search._op_onlyTypes = IcePy.Operation('onlyTypes', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, None, (), (((), _M_omero.api._t_StringSet, False, 0),), (), None, (_M_omero._t_ServerError,))
    Search._op_allTypes = IcePy.Operation('allTypes', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, None, (), (), (), None, (_M_omero._t_ServerError,))
    Search._op_onlyIds = IcePy.Operation('onlyIds', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, None, (), (((), _M_omero.sys._t_LongList, False, 0),), (), None, (_M_omero._t_ServerError,))
    Search._op_onlyOwnedBy = IcePy.Operation('onlyOwnedBy', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, None, (), (((), _M_omero.model._t_Details, False, 0),), (), None, (_M_omero._t_ServerError,))
    Search._op_notOwnedBy = IcePy.Operation('notOwnedBy', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, None, (), (((), _M_omero.model._t_Details, False, 0),), (), None, (_M_omero._t_ServerError,))
    Search._op_onlyCreatedBetween = IcePy.Operation('onlyCreatedBetween', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, None, (), (((), _M_omero._t_RTime, False, 0), ((), _M_omero._t_RTime, False, 0)), (), None, (_M_omero._t_ServerError,))
    Search._op_onlyModifiedBetween = IcePy.Operation('onlyModifiedBetween', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, None, (), (((), _M_omero._t_RTime, False, 0), ((), _M_omero._t_RTime, False, 0)), (), None, (_M_omero._t_ServerError,))
    Search._op_onlyAnnotatedBetween = IcePy.Operation('onlyAnnotatedBetween', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, None, (), (((), _M_omero._t_RTime, False, 0), ((), _M_omero._t_RTime, False, 0)), (), None, (_M_omero._t_ServerError,))
    Search._op_onlyAnnotatedBy = IcePy.Operation('onlyAnnotatedBy', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, None, (), (((), _M_omero.model._t_Details, False, 0),), (), None, (_M_omero._t_ServerError,))
    Search._op_notAnnotatedBy = IcePy.Operation('notAnnotatedBy', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, None, (), (((), _M_omero.model._t_Details, False, 0),), (), None, (_M_omero._t_ServerError,))
    Search._op_onlyAnnotatedWith = IcePy.Operation('onlyAnnotatedWith', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, None, (), (((), _M_omero.api._t_StringSet, False, 0),), (), None, (_M_omero._t_ServerError,))
    Search._op_addOrderByAsc = IcePy.Operation('addOrderByAsc', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, None, (), (((), IcePy._t_string, False, 0),), (), None, (_M_omero._t_ServerError,))
    Search._op_addOrderByDesc = IcePy.Operation('addOrderByDesc', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, None, (), (((), IcePy._t_string, False, 0),), (), None, (_M_omero._t_ServerError,))
    Search._op_unordered = IcePy.Operation('unordered', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, None, (), (), (), None, (_M_omero._t_ServerError,))
    Search._op_fetchAnnotations = IcePy.Operation('fetchAnnotations', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, None, (), (((), _M_omero.api._t_StringSet, False, 0),), (), None, (_M_omero._t_ServerError,))
    Search._op_fetchAlso = IcePy.Operation('fetchAlso', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, None, (), (((), _M_omero.api._t_StringSet, False, 0),), (), None, (_M_omero._t_ServerError,))
    Search._op_resetDefaults = IcePy.Operation('resetDefaults', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, None, (), (), (), None, (_M_omero._t_ServerError,))
    Search._op_byGroupForTags = IcePy.Operation('byGroupForTags', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, None, (), (((), IcePy._t_string, False, 0),), (), None, (_M_omero._t_ServerError,))
    Search._op_byTagForGroups = IcePy.Operation('byTagForGroups', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, None, (), (((), IcePy._t_string, False, 0),), (), None, (_M_omero._t_ServerError,))
    Search._op_byFullText = IcePy.Operation('byFullText', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, None, (), (((), IcePy._t_string, False, 0),), (), None, (_M_omero._t_ServerError,))
    Search._op_byLuceneQueryBuilder = IcePy.Operation('byLuceneQueryBuilder', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, None, (), (((), IcePy._t_string, False, 0), ((), IcePy._t_string, False, 0), ((), IcePy._t_string, False, 0), ((), IcePy._t_string, False, 0), ((), IcePy._t_string, False, 0)), (), None, (_M_omero._t_ServerError,))
    Search._op_bySimilarTerms = IcePy.Operation('bySimilarTerms', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, None, (), (((), _M_omero.api._t_StringSet, False, 0),), (), None, (_M_omero._t_ServerError,))
    Search._op_byHqlQuery = IcePy.Operation('byHqlQuery', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, None, (), (((), IcePy._t_string, False, 0), ((), _M_omero.sys._t_Parameters, False, 0)), (), None, (_M_omero._t_ServerError,))
    Search._op_bySomeMustNone = IcePy.Operation('bySomeMustNone', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, None, (), (((), _M_omero.api._t_StringSet, False, 0), ((), _M_omero.api._t_StringSet, False, 0), ((), _M_omero.api._t_StringSet, False, 0)), (), None, (_M_omero._t_ServerError,))
    Search._op_byAnnotatedWith = IcePy.Operation('byAnnotatedWith', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, None, (), (((), _M_omero.api._t_AnnotationList, False, 0),), (), None, (_M_omero._t_ServerError,))
    Search._op_clearQueries = IcePy.Operation('clearQueries', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, None, (), (), (), None, (_M_omero._t_ServerError,))
    Search._op_and = IcePy.Operation('and', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, None, (), (), (), None, (_M_omero._t_ServerError,))
    Search._op_or = IcePy.Operation('or', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, None, (), (), (), None, (_M_omero._t_ServerError,))
    Search._op_not = IcePy.Operation('not', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, None, (), (), (), None, (_M_omero._t_ServerError,))
    Search._op_hasNext = IcePy.Operation('hasNext', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, True, None, (), (), (), ((), IcePy._t_bool, False, 0), (_M_omero._t_ServerError,))
    Search._op_next = IcePy.Operation('next', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, None, (), (), (), ((), _M_omero.model._t_IObject, False, 0), (_M_omero._t_ServerError,))
    Search._op_results = IcePy.Operation('results', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, None, (), (), (), ((), _M_omero.api._t_IObjectList, False, 0), (_M_omero._t_ServerError,))
    Search._op_currentMetadata = IcePy.Operation('currentMetadata', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, True, None, (), (), (), ((), _M_omero.api._t_SearchMetadata, False, 0), (_M_omero._t_ServerError,))
    Search._op_currentMetadataList = IcePy.Operation('currentMetadataList', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, True, None, (), (), (), ((), _M_omero.api._t_SearchMetadataList, False, 0), (_M_omero._t_ServerError,))
    Search._op_remove = IcePy.Operation('remove', Ice.OperationMode.Normal, Ice.OperationMode.Normal, True, None, (), (), (), None, (_M_omero._t_ServerError,))

    _M_omero.api.Search = Search
    del Search

    _M_omero.api.SearchPrx = SearchPrx
    del SearchPrx

# End of module omero.api

__name__ = 'omero'

# End of module omero
