• Home
• edu.internet2.middleware.grouper
• grouper
• 5.12.2
• source code

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

.middleware.grouper.grouper.5.12.2.source-code.grouper.cache.base.properties Maven / Gradle / Ivy

#
# Copyright 2016 Internet2
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

#
# Grouper Cache Configuration
#


########################################
## Config chaining hierarchy
## The grouper cache config uses Grouper Configuration Overlays (documented on wiki)
## By default the configuration is read from grouper.cache.base.properties
## (which should not be edited), and the grouper.cache.properties overlays
## the base settings.  See the grouper.cache.base.properties for the possible
## settings that can be applied to the grouper.cache.properties
########################################

# comma separated config files that override each other (files on the right override the left)
# each should start with file: or classpath:
# e.g. classpath:grouper.cache.base.properties, file:c:/temp/myFile.properties
# {valueType: "string", required: true, multiple: true}
grouper.cache.config.hierarchy = classpath:grouper.cache.base.properties, classpath:grouper.cache.properties, database:grouper

# seconds between checking to see if the config files are updated
# {valueType: "integer", required: true}
grouper.cache.config.secondsBetweenUpdateChecks = 600

########################################
## Cache settings
########################################

# where cache files are stored
# {valueType: "string", required: true}
grouper.cache.diskStorePath=java.io.tmpdir

########################################
## Use old ehcache.xml
########################################

# set ehcache.xml to a filename
# {valueType: "string"}
grouper.cache.ehcache.xml.filename =

# set ehcache.xml to a resource on the classpath (generally not ehcache.xml)
# {valueType: "string"}
grouper.cache.ehcache.xml.resource =

########################################
## Default cache
##    Default Cache configuration. These will applied to caches
##    programmatically created through the CacheManager.
##
##    The following attributes are required for defaultCache:
##
##    maxInMemory       - Sets the maximum number of objects that
##                        will be created in memory.
##    eternal           - Sets whether elements are eternal. If
##                        eternal,  timeouts are ignored and the
##                        element is never expired.
##    timeToIdleSeconds - Sets the time to idle for an element
##                        before it expires. Is only used if the
##                        element is not eternal.  Idle time is now -
##                        last accessed time.
##    timeToLiveSeconds - Sets the time to live for an element
##                        before it expires. Is only used if the
##                        element is not eternal.  TTL is now -
##                        creation time.
##    overflowToDisk    - Sets whether elements can overflow to
##                        disk when the in-memory cache has reached
##                        the maxInMemory limit.
##    statistics        - If stats on caches should be kept
########################################

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.defaultCache.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.defaultCache.eternal = true

# Sets the time to idle for an element before it expires. Is only used if the element is not eternal.  Idle time is now - last accessed time.
# {valueType: "integer", required: true}
cache.defaultCache.timeToIdleSeconds = 1000

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.defaultCache.timeToLiveSeconds = 1000

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.defaultCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.defaultCache.statistics = false

########################################
## Caches
########################################

# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3GroupDAO

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO.maxElementsInMemory = 500

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO.eternal = false

# Sets the time to idle for an element before it expires. Is only used if the element is not eternal.  Idle time is now - last accessed time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO.timeToIdleSeconds = 1

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO.timeToLiveSeconds = 1

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO.overflowToDisk = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3MemberDAO_FindBySubject.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3MemberDAO.FindBySubject

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3MemberDAO_FindBySubject.maxElementsInMemory = 5000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3MemberDAO_FindBySubject.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3MemberDAO_FindBySubject.timeToIdleSeconds = 5

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3MemberDAO_FindBySubject.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3MemberDAO_FindBySubject.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3MemberDAO_FindBySubject.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3MemberDAO_GetAllMembersSecure.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3MemberDAO.GetAllMembersSecure

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3MemberDAO_GetAllMembersSecure.maxElementsInMemory = 5000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3MemberDAO_GetAllMembersSecure.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3MemberDAO_GetAllMembersSecure.timeToIdleSeconds = 5

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3MemberDAO_GetAllMembersSecure.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3MemberDAO_GetAllMembersSecure.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3MemberDAO_GetAllMembersSecure.statistics = false



# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3MembershipDAO.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3MembershipDAO

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3MembershipDAO.maxElementsInMemory = 10000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3MembershipDAO.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3MembershipDAO.timeToIdleSeconds = 5

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3MembershipDAO.timeToLiveSeconds = 5

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3MembershipDAO.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3MembershipDAO.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3AttributeAssignActionDAO_FindByAttributeDefId.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3AttributeAssignActionDAO.FindByAttributeDefId

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeAssignActionDAO_FindByAttributeDefId.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeAssignActionDAO_FindByAttributeDefId.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeAssignActionDAO_FindByAttributeDefId.timeToIdleSeconds = 5

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeAssignActionDAO_FindByAttributeDefId.timeToLiveSeconds = 5

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeAssignActionDAO_FindByAttributeDefId.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeAssignActionDAO_FindByAttributeDefId.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3AttributeAssignDAO_FindById.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3AttributeAssignDAO.FindById

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeAssignDAO_FindById.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeAssignDAO_FindById.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeAssignDAO_FindById.timeToIdleSeconds = 5

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeAssignDAO_FindById.timeToLiveSeconds = 5

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeAssignDAO_FindById.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeAssignDAO_FindById.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.org_hibernate_cache_internal_StandardQueryCache.name = org.hibernate.cache.internal.StandardQueryCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.org_hibernate_cache_internal_StandardQueryCache.maxElementsInMemory = 500

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.org_hibernate_cache_internal_StandardQueryCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.org_hibernate_cache_internal_StandardQueryCache.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.org_hibernate_cache_internal_StandardQueryCache.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.org_hibernate_cache_internal_StandardQueryCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.org_hibernate_cache_internal_StandardQueryCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.org_hibernate_cache_spi_UpdateTimestampsCache.name = org.hibernate.cache.spi.UpdateTimestampsCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.org_hibernate_cache_spi_UpdateTimestampsCache.maxElementsInMemory = 5000
cache.name.org_hibernate_cache_spi_UpdateTimestampsCache.eternal = true

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.org_hibernate_cache_spi_UpdateTimestampsCache.overflowToDisk = true

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.org_hibernate_cache_spi_UpdateTimestampsCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.RegistrySubject.name = edu.internet2.middleware.grouper.RegistrySubject

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.RegistrySubject.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.RegistrySubject.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.RegistrySubject.timeToIdleSeconds = 1

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.RegistrySubject.timeToLiveSeconds = 1

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.RegistrySubject.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.RegistrySubject.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.GroupTypeTuple.name = edu.internet2.middleware.grouper.GroupTypeTuple

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.GroupTypeTuple.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.GroupTypeTuple.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.GroupTypeTuple.timeToIdleSeconds = 1

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.GroupTypeTuple.timeToLiveSeconds = 1

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.GroupTypeTuple.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.GroupTypeTuple.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.Field.name = edu.internet2.middleware.grouper.Field

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.Field.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.Field.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.Field.timeToIdleSeconds = 1

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.Field.timeToLiveSeconds = 1

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.Field.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.Field.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.RegistrySubjectAttribute.name = edu.internet2.middleware.grouper.RegistrySubjectAttribute

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.RegistrySubjectAttribute.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.RegistrySubjectAttribute.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.RegistrySubjectAttribute.timeToIdleSeconds = 1

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.RegistrySubjectAttribute.timeToLiveSeconds = 1

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.RegistrySubjectAttribute.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.RegistrySubjectAttribute.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.AuditType.name = edu.internet2.middleware.grouper.AuditType

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.AuditType.maxElementsInMemory = 500

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.AuditType.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.AuditType.timeToIdleSeconds = 1

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.AuditType.timeToLiveSeconds = 1

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.AuditType.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.AuditType.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.Attribute.name = edu.internet2.middleware.grouper.Attribute

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.Attribute.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.Attribute.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.Attribute.timeToIdleSeconds = 1

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.Attribute.timeToLiveSeconds = 1

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.Attribute.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.Attribute.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.Composite.name = edu.internet2.middleware.grouper.Composite

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.Composite.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.Composite.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.Composite.timeToIdleSeconds = 1

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.Composite.timeToLiveSeconds = 1

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.Composite.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.Composite.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.GroupType.name = edu.internet2.middleware.grouper.GroupType

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.GroupType.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.GroupType.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.GroupType.timeToIdleSeconds = 1

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.GroupType.timeToLiveSeconds = 1

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.GroupType.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.GroupType.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.Membership.name = edu.internet2.middleware.grouper.Membership

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.Membership.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.Membership.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.Membership.timeToIdleSeconds = 1

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.Membership.timeToLiveSeconds = 1

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.Membership.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.Membership.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.Group.name = edu.internet2.middleware.grouper.Group

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.Group.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.Group.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.Group.timeToIdleSeconds = 1

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.Group.timeToLiveSeconds = 1

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.Group.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.Group.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.Stem.name = edu.internet2.middleware.grouper.Stem

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.Stem.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.Stem.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.Stem.timeToIdleSeconds = 1

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.Stem.timeToLiveSeconds = 1

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.Stem.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.Stem.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.Member.name = edu.internet2.middleware.grouper.Member

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.Member.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.Member.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.Member.timeToIdleSeconds = 1

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.Member.timeToLiveSeconds = 1

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.Member.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.Member.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByName.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3StemDAO.FindByName

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByName.maxElementsInMemory = 2000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByName.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByName.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByName.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByName.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByName.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByUuid.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3StemDAO.FindByUuid

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByUuid.maxElementsInMemory = 2000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByUuid.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByUuid.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByUuid.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByUuid.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByUuid.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByName.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3GroupDAO.FindByName

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByName.maxElementsInMemory = 2000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByName.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByName.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByName.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByName.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByName.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByIdIndex.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3GroupDAO.FindByIdIndex

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByIdIndex.maxElementsInMemory = 2000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByIdIndex.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByIdIndex.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByIdIndex.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByIdIndex.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByIdIndex.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByIdIndexSecure.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3GroupDAO.FindByIdIndexSecure

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByIdIndexSecure.maxElementsInMemory = 2000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByIdIndexSecure.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByIdIndexSecure.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByIdIndexSecure.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByIdIndexSecure.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByIdIndexSecure.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByUuid.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3GroupDAO.FindByUuid

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByUuid.maxElementsInMemory = 2000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByUuid.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByUuid.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByUuid.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByUuid.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByUuid.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefDAO_FindByUuidsSecure.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3AttributeDefDAO.FindByUuidsSecure

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefDAO_FindByUuidsSecure.maxElementsInMemory = 2000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefDAO_FindByUuidsSecure.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefDAO_FindByUuidsSecure.timeToIdleSeconds = 5

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefDAO_FindByUuidsSecure.timeToLiveSeconds = 5

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefDAO_FindByUuidsSecure.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefDAO_FindByUuidsSecure.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindByUuidsSecure.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3AttributeDefNameDAO.FindByUuidsSecure

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindByUuidsSecure.maxElementsInMemory = 2000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindByUuidsSecure.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindByUuidsSecure.timeToIdleSeconds = 5

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindByUuidsSecure.timeToLiveSeconds = 5

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindByUuidsSecure.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindByUuidsSecure.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindByName.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3AttributeDefNameDAO.FindByName

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindByName.maxElementsInMemory = 2000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindByName.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindByName.timeToIdleSeconds = 5

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindByName.timeToLiveSeconds = 5

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindByName.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindByName.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindByNameCache.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3AttributeDefNameDAO.FindByNameCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindByNameCache.maxElementsInMemory = 2000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindByNameCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindByNameCache.timeToIdleSeconds = 60

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindByNameCache.timeToLiveSeconds = 60

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindByNameCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindByNameCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.audit_AuditType.name = edu.internet2.middleware.grouper.audit.AuditType

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.audit_AuditType.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.audit_AuditType.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.audit_AuditType.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.audit_AuditType.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.audit_AuditType.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.audit_AuditType.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.changeLog_ChangeLogType.name = edu.internet2.middleware.grouper.changeLog.ChangeLogType

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.changeLog_ChangeLogType.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.changeLog_ChangeLogType.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.changeLog_ChangeLogType.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.changeLog_ChangeLogType.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.changeLog_ChangeLogType.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.changeLog_ChangeLogType.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.ImmediateMembershipEntry.name = ImmediateMembershipEntry

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.ImmediateMembershipEntry.maxElementsInMemory = 100000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.ImmediateMembershipEntry.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.ImmediateMembershipEntry.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.ImmediateMembershipEntry.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.ImmediateMembershipEntry.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.ImmediateMembershipEntry.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.permissions_role_RoleSet.name = edu.internet2.middleware.grouper.permissions.role.RoleSet

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.permissions_role_RoleSet.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.permissions_role_RoleSet.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.permissions_role_RoleSet.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.permissions_role_RoleSet.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.permissions_role_RoleSet.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.permissions_role_RoleSet.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.attr_AttributeDefNameSet.name = edu.internet2.middleware.grouper.attr.AttributeDefNameSet

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.attr_AttributeDefNameSet.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.attr_AttributeDefNameSet.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.attr_AttributeDefNameSet.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.attr_AttributeDefNameSet.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.attr_AttributeDefNameSet.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.attr_AttributeDefNameSet.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.attr_assign_AttributeAssignActionSetView.name = edu.internet2.middleware.grouper.attr.assign.AttributeAssignActionSetView

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.attr_assign_AttributeAssignActionSetView.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.attr_assign_AttributeAssignActionSetView.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.attr_assign_AttributeAssignActionSetView.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.attr_assign_AttributeAssignActionSetView.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.attr_assign_AttributeAssignActionSetView.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.attr_assign_AttributeAssignActionSetView.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.attr_AttributeDef.name = edu.internet2.middleware.grouper.attr.AttributeDef

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.attr_AttributeDef.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.attr_AttributeDef.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.attr_AttributeDef.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.attr_AttributeDef.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.attr_AttributeDef.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.attr_AttributeDef.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.MembershipEntry.name = MembershipEntry

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.MembershipEntry.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.MembershipEntry.eternal = false

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.MembershipEntry.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.MembershipEntry.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.MembershipEntry.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.MembershipEntry.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.attr_assign_AttributeAssign.name = edu.internet2.middleware.grouper.attr.assign.AttributeAssign

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.attr_assign_AttributeAssign.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.attr_assign_AttributeAssign.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.attr_assign_AttributeAssign.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.attr_assign_AttributeAssign.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.attr_assign_AttributeAssign.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.attr_assign_AttributeAssign.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.attr_AttributeDefName.name = edu.internet2.middleware.grouper.attr.AttributeDefName

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.attr_AttributeDefName.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.attr_AttributeDefName.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.attr_AttributeDefName.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.attr_AttributeDefName.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.attr_AttributeDefName.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.attr_AttributeDefName.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.attr_finder_AttributeDefNameFinder_findByNameCache.name = edu.internet2.middleware.grouper.attr.finder.AttributeDefNameFinder.findByNameCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.attr_finder_AttributeDefNameFinder_findByNameCache.maxElementsInMemory = 2000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.attr_finder_AttributeDefNameFinder_findByNameCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.attr_finder_AttributeDefNameFinder_findByNameCache.timeToIdleSeconds = 60

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.attr_finder_AttributeDefNameFinder_findByNameCache.timeToLiveSeconds = 60

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.attr_finder_AttributeDefNameFinder_findByNameCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.attr_finder_AttributeDefNameFinder_findByNameCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.attr_AttributeDefScope.name = edu.internet2.middleware.grouper.attr.AttributeDefScope

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.attr_AttributeDefScope.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.attr_AttributeDefScope.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.attr_AttributeDefScope.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.attr_AttributeDefScope.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.attr_AttributeDefScope.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.attr_AttributeDefScope.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.attr_AttributeDefNameSetView.name = edu.internet2.middleware.grouper.attr.AttributeDefNameSetView

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.attr_AttributeDefNameSetView.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.attr_AttributeDefNameSetView.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.attr_AttributeDefNameSetView.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.attr_AttributeDefNameSetView.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.attr_AttributeDefNameSetView.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.attr_AttributeDefNameSetView.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.permissions_role_RoleSetView.name = edu.internet2.middleware.grouper.permissions.role.RoleSetView

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.permissions_role_RoleSetView.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.permissions_role_RoleSetView.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.permissions_role_RoleSetView.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.permissions_role_RoleSetView.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.permissions_role_RoleSetView.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.permissions_role_RoleSetView.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.attr_assign_AttributeAssignActionSet.name = edu.internet2.middleware.grouper.attr.assign.AttributeAssignActionSet

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.attr_assign_AttributeAssignActionSet.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.attr_assign_AttributeAssignActionSet.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.attr_assign_AttributeAssignActionSet.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.attr_assign_AttributeAssignActionSet.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.attr_assign_AttributeAssignActionSet.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.attr_assign_AttributeAssignActionSet.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.changeLog_ChangeLogConsumer.name = edu.internet2.middleware.grouper.changeLog.ChangeLogConsumer

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.changeLog_ChangeLogConsumer.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.changeLog_ChangeLogConsumer.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.changeLog_ChangeLogConsumer.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.changeLog_ChangeLogConsumer.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.changeLog_ChangeLogConsumer.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.changeLog_ChangeLogConsumer.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.attr_assign_AttributeAssignValue.name = edu.internet2.middleware.grouper.attr.assign.AttributeAssignValue

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.attr_assign_AttributeAssignValue.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.attr_assign_AttributeAssignValue.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.attr_assign_AttributeAssignValue.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.attr_assign_AttributeAssignValue.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.attr_assign_AttributeAssignValue.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.attr_assign_AttributeAssignValue.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.attr_assign_AttributeAssignAction.name = edu.internet2.middleware.grouper.attr.assign.AttributeAssignAction

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.attr_assign_AttributeAssignAction.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.attr_assign_AttributeAssignAction.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.attr_assign_AttributeAssignAction.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.attr_assign_AttributeAssignAction.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.attr_assign_AttributeAssignAction.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.attr_assign_AttributeAssignAction.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefScopeDAO_FindByUuidOrName.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3AttributeDefScopeDAO.FindByUuidOrName

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefScopeDAO_FindByUuidOrName.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefScopeDAO_FindByUuidOrName.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefScopeDAO_FindByUuidOrName.timeToIdleSeconds = 20

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefScopeDAO_FindByUuidOrName.timeToLiveSeconds = 20

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefScopeDAO_FindByUuidOrName.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefScopeDAO_FindByUuidOrName.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindByUuidOrName.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3AttributeDefNameDAO.FindByUuidOrName

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindByUuidOrName.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindByUuidOrName.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindByUuidOrName.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindByUuidOrName.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindByUuidOrName.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindByUuidOrName.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3AttributeAssignValueDAO_FindByAttributeAssignId.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3AttributeAssignValueDAO.FindByAttributeAssignId
cache.name.internal_dao_hib3_Hib3AttributeAssignValueDAO_FindByAttributeAssignId.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeAssignValueDAO_FindByAttributeAssignId.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeAssignValueDAO_FindByAttributeAssignId.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeAssignValueDAO_FindByAttributeAssignId.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeAssignValueDAO_FindByAttributeAssignId.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeAssignValueDAO_FindByAttributeAssignId.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib_Hib3AttributeAssignDAO_FindByAttributeTypeDefNameId.name = edu.internet2.middleware.grouper.internal.dao.hib.Hib3AttributeAssignDAO.FindByAttributeTypeDefNameId

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib_Hib3AttributeAssignDAO_FindByAttributeTypeDefNameId.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib_Hib3AttributeAssignDAO_FindByAttributeTypeDefNameId.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib_Hib3AttributeAssignDAO_FindByAttributeTypeDefNameId.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib_Hib3AttributeAssignDAO_FindByAttributeTypeDefNameId.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib_Hib3AttributeAssignDAO_FindByAttributeTypeDefNameId.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib_Hib3AttributeAssignDAO_FindByAttributeTypeDefNameId.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib_Hib3AttributeDefDAO_FindById.name = edu.internet2.middleware.grouper.internal.dao.hib.Hib3AttributeDefDAO.FindById

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib_Hib3AttributeDefDAO_FindById.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib_Hib3AttributeDefDAO_FindById.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib_Hib3AttributeDefDAO_FindById.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib_Hib3AttributeDefDAO_FindById.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib_Hib3AttributeDefDAO_FindById.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib_Hib3AttributeDefDAO_FindById.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib_Hib3AttributeDefDAO_FindByIdIndex.name = edu.internet2.middleware.grouper.internal.dao.hib.Hib3AttributeDefDAO.FindByIdIndex

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib_Hib3AttributeDefDAO_FindByIdIndex.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib_Hib3AttributeDefDAO_FindByIdIndex.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib_Hib3AttributeDefDAO_FindByIdIndex.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib_Hib3AttributeDefDAO_FindByIdIndex.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib_Hib3AttributeDefDAO_FindByIdIndex.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib_Hib3AttributeDefDAO_FindByIdIndex.statistics = false

cache.name.internal_dao_hib3_Hib3ChangeLogEntryDAO_FindBySequenceNumber.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3ChangeLogEntryDAO.FindBySequenceNumber

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3ChangeLogEntryDAO_FindBySequenceNumber.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3ChangeLogEntryDAO_FindBySequenceNumber.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3ChangeLogEntryDAO_FindBySequenceNumber.timeToIdleSeconds = 5

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3ChangeLogEntryDAO_FindBySequenceNumber.timeToLiveSeconds = 5

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3ChangeLogEntryDAO_FindBySequenceNumber.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3ChangeLogEntryDAO_FindBySequenceNumber.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3FieldDAO_FindAll.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3FieldDAO.FindAll

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3FieldDAO_FindAll.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3FieldDAO_FindAll.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3FieldDAO_FindAll.timeToIdleSeconds = 5

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3FieldDAO_FindAll.timeToLiveSeconds = 5

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3FieldDAO_FindAll.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3FieldDAO_FindAll.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefDAO_FindByName.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3AttributeDefDAO.FindByName

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefDAO_FindByName.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefDAO_FindByName.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefDAO_FindByName.timeToIdleSeconds = 5

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefDAO_FindByName.timeToLiveSeconds = 5

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefDAO_FindByName.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefDAO_FindByName.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefDAO_FindByAttributeDefNameIdSecure.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3AttributeDefDAO.FindByAttributeDefNameIdSecure

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefDAO_FindByAttributeDefNameIdSecure.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefDAO_FindByAttributeDefNameIdSecure.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefDAO_FindByAttributeDefNameIdSecure.timeToIdleSeconds = 5

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefDAO_FindByAttributeDefNameIdSecure.timeToLiveSeconds = 5

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefDAO_FindByAttributeDefNameIdSecure.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefDAO_FindByAttributeDefNameIdSecure.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.pit_PITField.name = edu.internet2.middleware.grouper.pit.PITField

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.pit_PITField.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.pit_PITField.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITField.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITField.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.pit_PITField.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.pit_PITField.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3PITFieldDAO_FindById.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3PITFieldDAO.FindById

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITFieldDAO_FindById.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITFieldDAO_FindById.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITFieldDAO_FindById.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITFieldDAO_FindById.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITFieldDAO_FindById.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITFieldDAO_FindById.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.pit_PITAttributeAssign.name = edu.internet2.middleware.grouper.pit.PITAttributeAssign

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.pit_PITAttributeAssign.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.pit_PITAttributeAssign.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITAttributeAssign.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITAttributeAssign.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.pit_PITAttributeAssign.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.pit_PITAttributeAssign.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.pit_PITAttributeAssignAction.name = edu.internet2.middleware.grouper.pit.PITAttributeAssignAction

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.pit_PITAttributeAssignAction.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.pit_PITAttributeAssignAction.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITAttributeAssignAction.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITAttributeAssignAction.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.pit_PITAttributeAssignAction.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.pit_PITAttributeAssignAction.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.pit_PITAttributeAssignActionSet.name = edu.internet2.middleware.grouper.pit.PITAttributeAssignActionSet

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.pit_PITAttributeAssignActionSet.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.pit_PITAttributeAssignActionSet.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITAttributeAssignActionSet.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITAttributeAssignActionSet.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.pit_PITAttributeAssignActionSet.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.pit_PITAttributeAssignActionSet.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.pit_PITAttributeAssignValue.name = edu.internet2.middleware.grouper.pit.PITAttributeAssignValue

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.pit_PITAttributeAssignValue.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.pit_PITAttributeAssignValue.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITAttributeAssignValue.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITAttributeAssignValue.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.pit_PITAttributeAssignValue.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.pit_PITAttributeAssignValue.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.pit_PITAttributeAssignValueView.name = edu.internet2.middleware.grouper.pit.PITAttributeAssignValueView

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.pit_PITAttributeAssignValueView.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.pit_PITAttributeAssignValueView.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITAttributeAssignValueView.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITAttributeAssignValueView.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.pit_PITAttributeAssignValueView.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.pit_PITAttributeAssignValueView.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.pit_PITAttributeDef.name = edu.internet2.middleware.grouper.pit.PITAttributeDef

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.pit_PITAttributeDef.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.pit_PITAttributeDef.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITAttributeDef.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITAttributeDef.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.pit_PITAttributeDef.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.pit_PITAttributeDef.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.pit_PITAttributeDefName.name = edu.internet2.middleware.grouper.pit.PITAttributeDefName

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.pit_PITAttributeDefName.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.pit_PITAttributeDefName.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITAttributeDefName.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITAttributeDefName.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.pit_PITAttributeDefName.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.pit_PITAttributeDefName.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.pit_PITAttributeDefNameSet.name = edu.internet2.middleware.grouper.pit.PITAttributeDefNameSet

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.pit_PITAttributeDefNameSet.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.pit_PITAttributeDefNameSet.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITAttributeDefNameSet.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITAttributeDefNameSet.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.pit_PITAttributeDefNameSet.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.pit_PITAttributeDefNameSet.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.pit_PITGroup.name = edu.internet2.middleware.grouper.pit.PITGroup

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.pit_PITGroup.maxElementsInMemory = 5000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.pit_PITGroup.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITGroup.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITGroup.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.pit_PITGroup.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.pit_PITGroup.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.pit_PITGroupSet.name = edu.internet2.middleware.grouper.pit.PITGroupSet

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.pit_PITGroupSet.maxElementsInMemory = 100000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.pit_PITGroupSet.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITGroupSet.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITGroupSet.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.pit_PITGroupSet.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.pit_PITGroupSet.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.pit_PITMember.name = edu.internet2.middleware.grouper.pit.PITMember

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.pit_PITMember.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.pit_PITMember.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITMember.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITMember.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.pit_PITMember.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.pit_PITMember.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.pit_PITMembership.name = edu.internet2.middleware.grouper.pit.PITMembership

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.pit_PITMembership.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.pit_PITMembership.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITMembership.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITMembership.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.pit_PITMembership.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.pit_PITMembership.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.pit_PITMembershipView.name = edu.internet2.middleware.grouper.pit.PITMembershipView

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.pit_PITMembershipView.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.pit_PITMembershipView.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITMembershipView.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITMembershipView.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.pit_PITMembershipView.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.pit_PITMembershipView.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.pit_PITPermissionAllView.name = edu.internet2.middleware.grouper.pit.PITPermissionAllView

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.pit_PITPermissionAllView.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.pit_PITPermissionAllView.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITPermissionAllView.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITPermissionAllView.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.pit_PITPermissionAllView.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.pit_PITPermissionAllView.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.pit_PITRoleSet.name = edu.internet2.middleware.grouper.pit.PITRoleSet

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.pit_PITRoleSet.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.pit_PITRoleSet.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITRoleSet.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITRoleSet.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.pit_PITRoleSet.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.pit_PITRoleSet.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.pit_PITStem.name = edu.internet2.middleware.grouper.pit.PITStem

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.pit_PITStem.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.pit_PITStem.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITStem.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITStem.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.pit_PITStem.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.pit_PITStem.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignActionDAO_FindById.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3PITAttributeAssignActionDAO.FindById

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignActionDAO_FindById.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignActionDAO_FindById.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignActionDAO_FindById.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignActionDAO_FindById.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignActionDAO_FindById.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignActionDAO_FindById.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignActionSetDAO_FindById.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3PITAttributeAssignActionSetDAO.FindById

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignActionSetDAO_FindById.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignActionSetDAO_FindById.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignActionSetDAO_FindById.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignActionSetDAO_FindById.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignActionSetDAO_FindById.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignActionSetDAO_FindById.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignDAO_FindById.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3PITAttributeAssignDAO.FindById

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignDAO_FindById.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignDAO_FindById.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignDAO_FindById.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignDAO_FindById.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignDAO_FindById.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignDAO_FindById.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignValueDAO_FindById.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3PITAttributeAssignValueDAO.FindById

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignValueDAO_FindById.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignValueDAO_FindById.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignValueDAO_FindById.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignValueDAO_FindById.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignValueDAO_FindById.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignValueDAO_FindById.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefDAO_FindById.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3PITAttributeDefDAO.FindById

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefDAO_FindById.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefDAO_FindById.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefDAO_FindById.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefDAO_FindById.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefDAO_FindById.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefDAO_FindById.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefNameDAO_FindById.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3PITAttributeDefNameDAO.FindById

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefNameDAO_FindById.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefNameDAO_FindById.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefNameDAO_FindById.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefNameDAO_FindById.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefNameDAO_FindById.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefNameDAO_FindById.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefNameSetDAO_FindById.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3PITAttributeDefNameSetDAO.FindById

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefNameSetDAO_FindById.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefNameSetDAO_FindById.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefNameSetDAO_FindById.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefNameSetDAO_FindById.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefNameSetDAO_FindById.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefNameSetDAO_FindById.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3PITGroupDAO_FindById.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3PITGroupDAO.FindById

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITGroupDAO_FindById.maxElementsInMemory = 5000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITGroupDAO_FindById.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITGroupDAO_FindById.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITGroupDAO_FindById.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITGroupDAO_FindById.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITGroupDAO_FindById.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3PITGroupSetDAO_FindById.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3PITGroupSetDAO.FindById

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITGroupSetDAO_FindById.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITGroupSetDAO_FindById.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITGroupSetDAO_FindById.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITGroupSetDAO_FindById.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITGroupSetDAO_FindById.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITGroupSetDAO_FindById.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3PITMemberDAO_FindById.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3PITMemberDAO.FindById

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITMemberDAO_FindById.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITMemberDAO_FindById.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITMemberDAO_FindById.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITMemberDAO_FindById.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITMemberDAO_FindById.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITMemberDAO_FindById.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3PITMembershipDAO_FindById.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3PITMembershipDAO.FindById

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITMembershipDAO_FindById.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITMembershipDAO_FindById.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITMembershipDAO_FindById.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITMembershipDAO_FindById.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITMembershipDAO_FindById.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITMembershipDAO_FindById.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3PITRoleSetDAO_FindById.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3PITRoleSetDAO.FindById

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITRoleSetDAO_FindById.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITRoleSetDAO_FindById.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITRoleSetDAO_FindById.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITRoleSetDAO_FindById.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITRoleSetDAO_FindById.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITRoleSetDAO_FindById.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3PITStemDAO_FindById.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3PITStemDAO.FindById

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITStemDAO_FindById.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITStemDAO_FindById.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITStemDAO_FindById.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITStemDAO_FindById.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITStemDAO_FindById.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITStemDAO_FindById.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignActionDAO_FindBySourceIdActive.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3PITAttributeAssignActionDAO.FindBySourceIdActive

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignActionDAO_FindBySourceIdActive.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignActionDAO_FindBySourceIdActive.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignActionDAO_FindBySourceIdActive.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignActionDAO_FindBySourceIdActive.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignActionDAO_FindBySourceIdActive.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignActionDAO_FindBySourceIdActive.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignActionSetDAO_FindBySourceIdActive.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3PITAttributeAssignActionSetDAO.FindBySourceIdActive

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignActionSetDAO_FindBySourceIdActive.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignActionSetDAO_FindBySourceIdActive.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignActionSetDAO_FindBySourceIdActive.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignActionSetDAO_FindBySourceIdActive.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignActionSetDAO_FindBySourceIdActive.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignActionSetDAO_FindBySourceIdActive.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignDAO_FindBySourceIdActive.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3PITAttributeAssignDAO.FindBySourceIdActive

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignDAO_FindBySourceIdActive.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignDAO_FindBySourceIdActive.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignDAO_FindBySourceIdActive.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignDAO_FindBySourceIdActive.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignDAO_FindBySourceIdActive.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignDAO_FindBySourceIdActive.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignValueDAO_FindBySourceIdActive.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3PITAttributeAssignValueDAO.FindBySourceIdActive

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignValueDAO_FindBySourceIdActive.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignValueDAO_FindBySourceIdActive.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignValueDAO_FindBySourceIdActive.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignValueDAO_FindBySourceIdActive.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignValueDAO_FindBySourceIdActive.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeAssignValueDAO_FindBySourceIdActive.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefDAO_FindBySourceIdActive.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3PITAttributeDefDAO.FindBySourceIdActive

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefDAO_FindBySourceIdActive.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefDAO_FindBySourceIdActive.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefDAO_FindBySourceIdActive.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefDAO_FindBySourceIdActive.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefDAO_FindBySourceIdActive.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefDAO_FindBySourceIdActive.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefNameDAO_FindBySourceIdActive.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3PITAttributeDefNameDAO.FindBySourceIdActive

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefNameDAO_FindBySourceIdActive.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefNameDAO_FindBySourceIdActive.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefNameDAO_FindBySourceIdActive.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefNameDAO_FindBySourceIdActive.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefNameDAO_FindBySourceIdActive.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefNameDAO_FindBySourceIdActive.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefNameSetDAO_FindBySourceIdActive.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3PITAttributeDefNameSetDAO.FindBySourceIdActive

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefNameSetDAO_FindBySourceIdActive.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefNameSetDAO_FindBySourceIdActive.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefNameSetDAO_FindBySourceIdActive.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefNameSetDAO_FindBySourceIdActive.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefNameSetDAO_FindBySourceIdActive.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITAttributeDefNameSetDAO_FindBySourceIdActive.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3PITGroupDAO_FindBySourceIdActive.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3PITGroupDAO.FindBySourceIdActive

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITGroupDAO_FindBySourceIdActive.maxElementsInMemory = 5000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITGroupDAO_FindBySourceIdActive.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITGroupDAO_FindBySourceIdActive.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITGroupDAO_FindBySourceIdActive.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITGroupDAO_FindBySourceIdActive.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITGroupDAO_FindBySourceIdActive.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3PITGroupSetDAO_FindBySourceIdActive.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3PITGroupSetDAO.FindBySourceIdActive

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITGroupSetDAO_FindBySourceIdActive.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITGroupSetDAO_FindBySourceIdActive.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITGroupSetDAO_FindBySourceIdActive.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITGroupSetDAO_FindBySourceIdActive.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITGroupSetDAO_FindBySourceIdActive.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITGroupSetDAO_FindBySourceIdActive.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3PITMemberDAO_FindBySourceIdActive.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3PITMemberDAO.FindBySourceIdActive

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITMemberDAO_FindBySourceIdActive.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITMemberDAO_FindBySourceIdActive.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITMemberDAO_FindBySourceIdActive.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITMemberDAO_FindBySourceIdActive.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITMemberDAO_FindBySourceIdActive.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITMemberDAO_FindBySourceIdActive.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3PITMembershipDAO_FindBySourceIdActive.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3PITMembershipDAO.FindBySourceIdActive

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITMembershipDAO_FindBySourceIdActive.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITMembershipDAO_FindBySourceIdActive.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITMembershipDAO_FindBySourceIdActive.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITMembershipDAO_FindBySourceIdActive.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITMembershipDAO_FindBySourceIdActive.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITMembershipDAO_FindBySourceIdActive.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3PITRoleSetDAO_FindBySourceIdActive.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3PITRoleSetDAO.FindBySourceIdActive

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITRoleSetDAO_FindBySourceIdActive.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITRoleSetDAO_FindBySourceIdActive.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITRoleSetDAO_FindBySourceIdActive.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITRoleSetDAO_FindBySourceIdActive.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITRoleSetDAO_FindBySourceIdActive.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITRoleSetDAO_FindBySourceIdActive.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3PITStemDAO_FindBySourceIdActive.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3PITStemDAO.FindBySourceIdActive

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITStemDAO_FindBySourceIdActive.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITStemDAO_FindBySourceIdActive.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITStemDAO_FindBySourceIdActive.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITStemDAO_FindBySourceIdActive.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITStemDAO_FindBySourceIdActive.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITStemDAO_FindBySourceIdActive.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3PITFieldDAO_FindBySourceIdActive.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3PITFieldDAO.FindBySourceIdActive

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITFieldDAO_FindBySourceIdActive.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITFieldDAO_FindBySourceIdActive.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITFieldDAO_FindBySourceIdActive.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3PITFieldDAO_FindBySourceIdActive.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITFieldDAO_FindBySourceIdActive.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3PITFieldDAO_FindBySourceIdActive.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.group_GroupSet.name = edu.internet2.middleware.grouper.group.GroupSet

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.group_GroupSet.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.group_GroupSet.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.group_GroupSet.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.group_GroupSet.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.group_GroupSet.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.group_GroupSet.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.externalSubjects_ExternalSubject.name = edu.internet2.middleware.grouper.externalSubjects.ExternalSubject

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.externalSubjects_ExternalSubject.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.externalSubjects_ExternalSubject.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.externalSubjects_ExternalSubject.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.externalSubjects_ExternalSubject.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.externalSubjects_ExternalSubject.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.externalSubjects_ExternalSubject.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.externalSubjects_ExternalSubjectAttribute.name = edu.internet2.middleware.grouper.externalSubjects.ExternalSubjectAttribute

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.externalSubjects_ExternalSubjectAttribute.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.externalSubjects_ExternalSubjectAttribute.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.externalSubjects_ExternalSubjectAttribute.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.externalSubjects_ExternalSubjectAttribute.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.externalSubjects_ExternalSubjectAttribute.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.externalSubjects_ExternalSubjectAttribute.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.attr_value_AttributeAssignValue.name = edu.internet2.middleware.grouper.attr.value.AttributeAssignValue

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.attr_value_AttributeAssignValue.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.attr_value_AttributeAssignValue.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.attr_value_AttributeAssignValue.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.attr_value_AttributeAssignValue.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.attr_value_AttributeAssignValue.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.attr_value_AttributeAssignValue.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByUuidsSecure.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3GroupDAO.FindByUuidsSecure

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByUuidsSecure.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByUuidsSecure.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByUuidsSecure.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByUuidsSecure.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByUuidsSecure.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByUuidsSecure.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByNamesSecure.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3GroupDAO.FindByNamesSecure

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByNamesSecure.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByNamesSecure.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByNamesSecure.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByNamesSecure.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByNamesSecure.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3GroupDAO_FindByNamesSecure.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefDAO_FindById.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3AttributeDefDAO.FindById

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefDAO_FindById.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefDAO_FindById.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefDAO_FindById.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefDAO_FindById.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefDAO_FindById.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefDAO_FindById.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByCurrentName.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3StemDAO.FindByCurrentName

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByCurrentName.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByCurrentName.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByCurrentName.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByCurrentName.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByCurrentName.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByCurrentName.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByIdIndex.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3StemDAO.FindByIdIndex

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByIdIndex.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByIdIndex.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByIdIndex.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByIdIndex.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByIdIndex.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByIdIndex.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByAlternateName.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3StemDAO.FindByAlternateName

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByAlternateName.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByAlternateName.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByAlternateName.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByAlternateName.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByAlternateName.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3StemDAO_FindByAlternateName.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3GroupTypeTupleDAO_FindByUuidOrKey.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3GroupTypeTupleDAO.FindByUuidOrKey

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3GroupTypeTupleDAO_FindByUuidOrKey.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3GroupTypeTupleDAO_FindByUuidOrKey.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3GroupTypeTupleDAO_FindByUuidOrKey.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3GroupTypeTupleDAO_FindByUuidOrKey.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3GroupTypeTupleDAO_FindByUuidOrKey.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3GroupTypeTupleDAO_FindByUuidOrKey.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3CompositeDAO_FindByUuidOrName.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3CompositeDAO.FindByUuidOrName

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3CompositeDAO_FindByUuidOrName.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3CompositeDAO_FindByUuidOrName.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3CompositeDAO_FindByUuidOrName.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3CompositeDAO_FindByUuidOrName.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3CompositeDAO_FindByUuidOrName.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3CompositeDAO_FindByUuidOrName.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3GroupSetDAO_FindSelfStem.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3GroupSetDAO.FindSelfStem

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3GroupSetDAO_FindSelfStem.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3GroupSetDAO_FindSelfStem.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3GroupSetDAO_FindSelfStem.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3GroupSetDAO_FindSelfStem.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3GroupSetDAO_FindSelfStem.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3GroupSetDAO_FindSelfStem.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3GroupSetDAO_FindSelfGroup.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3GroupSetDAO.FindSelfGroup

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3GroupSetDAO_FindSelfGroup.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3GroupSetDAO_FindSelfGroup.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3GroupSetDAO_FindSelfGroup.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3GroupSetDAO_FindSelfGroup.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3GroupSetDAO_FindSelfGroup.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3GroupSetDAO_FindSelfGroup.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3FieldDAO_FindByUuidOrName.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3FieldDAO.FindByUuidOrName

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3FieldDAO_FindByUuidOrName.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3FieldDAO_FindByUuidOrName.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3FieldDAO_FindByUuidOrName.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3FieldDAO_FindByUuidOrName.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3FieldDAO_FindByUuidOrName.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3FieldDAO_FindByUuidOrName.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3AttributeAssignActionDAO_FindByUuidOrName.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3AttributeAssignActionDAO.FindByUuidOrName

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeAssignActionDAO_FindByUuidOrName.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeAssignActionDAO_FindByUuidOrName.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeAssignActionDAO_FindByUuidOrName.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeAssignActionDAO_FindByUuidOrName.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeAssignActionDAO_FindByUuidOrName.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeAssignActionDAO_FindByUuidOrName.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindAll.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3AttributeDefNameDAO.FindAll

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindAll.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindAll.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindAll.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindAll.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindAll.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeDefNameDAO_FindAll.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3AttributeAssignDAO_FindByUuidOrKey.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3AttributeAssignDAO.FindByUuidOrKey

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeAssignDAO_FindByUuidOrKey.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeAssignDAO_FindByUuidOrKey.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeAssignDAO_FindByUuidOrKey.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AttributeAssignDAO_FindByUuidOrKey.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeAssignDAO_FindByUuidOrKey.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AttributeAssignDAO_FindByUuidOrKey.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3GroupSetDAO_FindByOwnerMemberFieldParentAndType.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3GroupSetDAO.FindByOwnerMemberFieldParentAndType

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3GroupSetDAO_FindByOwnerMemberFieldParentAndType.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3GroupSetDAO_FindByOwnerMemberFieldParentAndType.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3GroupSetDAO_FindByOwnerMemberFieldParentAndType.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3GroupSetDAO_FindByOwnerMemberFieldParentAndType.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3GroupSetDAO_FindByOwnerMemberFieldParentAndType.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3GroupSetDAO_FindByOwnerMemberFieldParentAndType.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3AuditTypeDAO_FindByCategory.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3AuditTypeDAO.FindByCategory

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AuditTypeDAO_FindByCategory.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AuditTypeDAO_FindByCategory.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AuditTypeDAO_FindByCategory.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AuditTypeDAO_FindByCategory.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AuditTypeDAO_FindByCategory.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AuditTypeDAO_FindByCategory.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3AuditTypeDAO_FindByUuidOrName.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3AuditTypeDAO.FindByUuidOrName

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AuditTypeDAO_FindByUuidOrName.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AuditTypeDAO_FindByUuidOrName.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AuditTypeDAO_FindByUuidOrName.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AuditTypeDAO_FindByUuidOrName.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AuditTypeDAO_FindByUuidOrName.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AuditTypeDAO_FindByUuidOrName.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3AuditEntryDAO_FindByActingUser.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3AuditEntryDAO.FindByActingUser

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AuditEntryDAO_FindByActingUser.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AuditEntryDAO_FindByActingUser.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AuditEntryDAO_FindByActingUser.timeToIdleSeconds = 120

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3AuditEntryDAO_FindByActingUser.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AuditEntryDAO_FindByActingUser.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3AuditEntryDAO_FindByActingUser.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.privs_CachingAccessResolver_HasPrivilege.name = edu.internet2.middleware.grouper.privs.CachingAccessResolver.HasPrivilege

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.privs_CachingAccessResolver_HasPrivilege.maxElementsInMemory = 500

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.privs_CachingAccessResolver_HasPrivilege.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.privs_CachingAccessResolver_HasPrivilege.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.privs_CachingAccessResolver_HasPrivilege.timeToLiveSeconds = 30

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.privs_CachingAccessResolver_HasPrivilege.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.privs_CachingAccessResolver_HasPrivilege.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.privs_CachingNamingResolver_HasPrivilege.name = edu.internet2.middleware.grouper.privs.CachingNamingResolver.HasPrivilege

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.privs_CachingNamingResolver_HasPrivilege.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.privs_CachingNamingResolver_HasPrivilege.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.privs_CachingNamingResolver_HasPrivilege.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.privs_CachingNamingResolver_HasPrivilege.timeToLiveSeconds = 30

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.privs_CachingNamingResolver_HasPrivilege.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.privs_CachingNamingResolver_HasPrivilege.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.privs_CachingAttrDefResolver_HasPrivilege.name = edu.internet2.middleware.grouper.privs.CachingAttrDefResolver.HasPrivilege

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.privs_CachingAttrDefResolver_HasPrivilege.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.privs_CachingAttrDefResolver_HasPrivilege.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.privs_CachingAttrDefResolver_HasPrivilege.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.privs_CachingAttrDefResolver_HasPrivilege.timeToLiveSeconds = 30

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.privs_CachingAttrDefResolver_HasPrivilege.overflowToDisk = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.subj_CachingResolver_Find.name = edu.internet2.middleware.grouper.subj.CachingResolver.Find

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.subj_CachingResolver_Find.maxElementsInMemory = 5000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.subj_CachingResolver_Find.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.subj_CachingResolver_Find.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.subj_CachingResolver_Find.timeToLiveSeconds = 30

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.subj_CachingResolver_Find.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.subj_CachingResolver_Find.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.subj_CachingResolver_FindAll.name = edu.internet2.middleware.grouper.subj.CachingResolver.FindAll

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.subj_CachingResolver_FindAll.maxElementsInMemory = 5000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.subj_CachingResolver_FindAll.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.subj_CachingResolver_FindAll.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.subj_CachingResolver_FindAll.timeToLiveSeconds = 30

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.subj_CachingResolver_FindAll.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.subj_CachingResolver_FindAll.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.subj_CachingResolver_FindPage.name = edu.internet2.middleware.grouper.subj.CachingResolver.FindPage

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.subj_CachingResolver_FindPage.maxElementsInMemory = 5000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.subj_CachingResolver_FindPage.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.subj_CachingResolver_FindPage.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.subj_CachingResolver_FindPage.timeToLiveSeconds = 30

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.subj_CachingResolver_FindPage.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.subj_CachingResolver_FindPage.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.subj_CachingResolver_FindByIdentifier.name = edu.internet2.middleware.grouper.subj.CachingResolver.FindByIdentifier

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.subj_CachingResolver_FindByIdentifier.maxElementsInMemory = 5000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.subj_CachingResolver_FindByIdentifier.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.subj_CachingResolver_FindByIdentifier.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.subj_CachingResolver_FindByIdentifier.timeToLiveSeconds = 30

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.subj_CachingResolver_FindByIdentifier.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.subj_CachingResolver_FindByIdentifier.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.subj_CachingResolver_FindByIdOrIdentifier.name = edu.internet2.middleware.grouper.subj.CachingResolver.FindByIdOrIdentifier

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.subj_CachingResolver_FindByIdOrIdentifier.maxElementsInMemory = 5000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.subj_CachingResolver_FindByIdOrIdentifier.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.subj_CachingResolver_FindByIdOrIdentifier.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.subj_CachingResolver_FindByIdOrIdentifier.timeToLiveSeconds = 30

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.subj_CachingResolver_FindByIdOrIdentifier.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.subj_CachingResolver_FindByIdOrIdentifier.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.attr_AttributeDefName_CanAdminAttributeDef.name = edu.internet2.middleware.grouper.attr.AttributeDefName.CanAdminAttributeDef

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.attr_AttributeDefName_CanAdminAttributeDef.maxElementsInMemory = 5000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.attr_AttributeDefName_CanAdminAttributeDef.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.attr_AttributeDefName_CanAdminAttributeDef.timeToIdleSeconds = 5

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.attr_AttributeDefName_CanAdminAttributeDef.timeToLiveSeconds = 5

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.attr_AttributeDefName_CanAdminAttributeDef.overflowToDisk = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.privs_WheelCache_isWheelMember.name = edu.internet2.middleware.grouper.privs.WheelCache.isWheelMember

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.privs_WheelCache_isWheelMember.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.privs_WheelCache_isWheelMember.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.privs_WheelCache_isWheelMember.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.privs_WheelCache_isWheelMember.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.privs_WheelCache_isWheelMember.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.privs_WheelCache_isWheelMember.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.Membership_getGroup.name = edu.internet2.middleware.grouper.Membership.getGroup

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.Membership_getGroup.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.Membership_getGroup.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.Membership_getGroup.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.Membership_getGroup.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.Membership_getGroup.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.Membership_getGroup.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.Membership_getStem.name = edu.internet2.middleware.grouper.Membership.getStem

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.Membership_getStem.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.Membership_getStem.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.Membership_getStem.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.Membership_getStem.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.Membership_getStem.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.Membership_getStem.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.Membership_getAttributeDef.name = edu.internet2.middleware.grouper.Membership.getAttributeDef

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.Membership_getAttributeDef.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.Membership_getAttributeDef.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.Membership_getAttributeDef.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.Membership_getAttributeDef.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.Membership_getAttributeDef.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.Membership_getAttributeDef.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3MemberDAO_exists.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3MemberDAO.exists

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3MemberDAO_exists.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3MemberDAO_exists.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3MemberDAO_exists.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3MemberDAO_exists.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3MemberDAO_exists.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3MemberDAO_exists.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.internal_dao_hib3_Hib3MemberDAO_find.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3MemberDAO.find

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3MemberDAO_find.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3MemberDAO_find.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3MemberDAO_find.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.internal_dao_hib3_Hib3MemberDAO_find.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3MemberDAO_find.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.internal_dao_hib3_Hib3MemberDAO_find.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.AttributeAssignBaseDelegate_allAttributeAssignsCache.name = AttributeAssignBaseDelegate.allAttributeAssignsCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.AttributeAssignBaseDelegate_allAttributeAssignsCache.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.AttributeAssignBaseDelegate_allAttributeAssignsCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.AttributeAssignBaseDelegate_allAttributeAssignsCache.timeToIdleSeconds = 1200

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.AttributeAssignBaseDelegate_allAttributeAssignsCache.timeToLiveSeconds = 1200

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.AttributeAssignBaseDelegate_allAttributeAssignsCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.AttributeAssignBaseDelegate_allAttributeAssignsCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.entity_EntitySubject_EntityAttributeIdCache.name = edu.internet2.middleware.grouper.entity.EntitySubject.EntityAttributeIdCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.entity_EntitySubject_EntityAttributeIdCache.maxElementsInMemory = 5000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.entity_EntitySubject_EntityAttributeIdCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.entity_EntitySubject_EntityAttributeIdCache.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.entity_EntitySubject_EntityAttributeIdCache.timeToLiveSeconds = 30

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.entity_EntitySubject_EntityAttributeIdCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.entity_EntitySubject_EntityAttributeIdCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.userData_GrouperUserDataUtils_userDataGroupCache.name = edu.internet2.middleware.grouper.userData.GrouperUserDataUtils.userDataGroupCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.userData_GrouperUserDataUtils_userDataGroupCache.maxElementsInMemory = 100

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.userData_GrouperUserDataUtils_userDataGroupCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.userData_GrouperUserDataUtils_userDataGroupCache.timeToIdleSeconds = 600

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.userData_GrouperUserDataUtils_userDataGroupCache.timeToLiveSeconds = 600

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.userData_GrouperUserDataUtils_userDataGroupCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.userData_GrouperUserDataUtils_userDataGroupCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.userData_GrouperUserDataUtils_userDataMembershipCache.name = edu.internet2.middleware.grouper.userData.GrouperUserDataUtils.userDataMembershipCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.userData_GrouperUserDataUtils_userDataMembershipCache.maxElementsInMemory = 100

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.userData_GrouperUserDataUtils_userDataMembershipCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.userData_GrouperUserDataUtils_userDataMembershipCache.timeToIdleSeconds = 600

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.userData_GrouperUserDataUtils_userDataMembershipCache.timeToLiveSeconds = 600

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.userData_GrouperUserDataUtils_userDataMembershipCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.userData_GrouperUserDataUtils_userDataMembershipCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.userData_GrouperUserDataUtils_userDataAttributeValueCache.name = edu.internet2.middleware.grouper.userData.GrouperUserDataUtils.userDataAttributeValueCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.userData_GrouperUserDataUtils_userDataAttributeValueCache.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.userData_GrouperUserDataUtils_userDataAttributeValueCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.userData_GrouperUserDataUtils_userDataAttributeValueCache.timeToIdleSeconds = 120

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.userData_GrouperUserDataUtils_userDataAttributeValueCache.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.userData_GrouperUserDataUtils_userDataAttributeValueCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.userData_GrouperUserDataUtils_userDataAttributeValueCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.userData_GrouperUserDataUtils_userDataResultCache.name = edu.internet2.middleware.grouper.userData.GrouperUserDataUtils.userDataResultCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.userData_GrouperUserDataUtils_userDataResultCache.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.userData_GrouperUserDataUtils_userDataResultCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.userData_GrouperUserDataUtils_userDataResultCache.timeToIdleSeconds = 120

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.userData_GrouperUserDataUtils_userDataResultCache.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.userData_GrouperUserDataUtils_userDataResultCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.userData_GrouperUserDataUtils_userDataResultCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.GroupType_attributeDefNameFromTypeIdCache.name = edu.internet2.middleware.grouper.GroupType.attributeDefNameFromTypeIdCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.GroupType_attributeDefNameFromTypeIdCache.maxElementsInMemory = 200

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.GroupType_attributeDefNameFromTypeIdCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.GroupType_attributeDefNameFromTypeIdCache.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.GroupType_attributeDefNameFromTypeIdCache.timeToLiveSeconds = 30

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.GroupType_attributeDefNameFromTypeIdCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.GroupType_attributeDefNameFromTypeIdCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.GroupType_legacyAttributesFromTypeIdCache.name = edu.internet2.middleware.grouper.GroupType.legacyAttributesFromTypeIdCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.GroupType_legacyAttributesFromTypeIdCache.maxElementsInMemory = 200

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.GroupType_legacyAttributesFromTypeIdCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.GroupType_legacyAttributesFromTypeIdCache.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.GroupType_legacyAttributesFromTypeIdCache.timeToLiveSeconds = 30

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.GroupType_legacyAttributesFromTypeIdCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.GroupType_legacyAttributesFromTypeIdCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.Stem_stemCreatedCache.name = edu.internet2.middleware.grouper.Stem.stemCreatedCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.Stem_stemCreatedCache.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.Stem_stemCreatedCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.Stem_stemCreatedCache.timeToIdleSeconds = 120

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.Stem_stemCreatedCache.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.Stem_stemCreatedCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.Stem_stemCreatedCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.Stem_stemLocksCache.name = edu.internet2.middleware.grouper.Stem.stemLocksCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.Stem_stemLocksCache.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.Stem_stemLocksCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.Stem_stemLocksCache.timeToIdleSeconds = 120

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.Stem_stemLocksCache.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.Stem_stemLocksCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.Stem_stemLocksCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.MemberFinder_memberCreatedCache.name = edu.internet2.middleware.grouper.MemberFinder.memberCreatedCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.MemberFinder_memberCreatedCache.maxElementsInMemory = 5000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.MemberFinder_memberCreatedCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.MemberFinder_memberCreatedCache.timeToIdleSeconds = 120

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.MemberFinder_memberCreatedCache.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.MemberFinder_memberCreatedCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.MemberFinder_memberCreatedCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.MemberFinder_memberLocksCache.name = edu.internet2.middleware.grouper.MemberFinder.memberLocksCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.MemberFinder_memberLocksCache.maxElementsInMemory = 5000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.MemberFinder_memberLocksCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.MemberFinder_memberLocksCache.timeToIdleSeconds = 120

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.MemberFinder_memberLocksCache.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.MemberFinder_memberLocksCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.MemberFinder_memberLocksCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.util_GrouperUtil_objectHasAttributeCache.name = edu.internet2.middleware.grouper.util.GrouperUtil.objectHasAttributeCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.util_GrouperUtil_objectHasAttributeCache.maxElementsInMemory = 5000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.util_GrouperUtil_objectHasAttributeCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.util_GrouperUtil_objectHasAttributeCache.timeToIdleSeconds = 60

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.util_GrouperUtil_objectHasAttributeCache.timeToLiveSeconds = 60

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.util_GrouperUtil_objectHasAttributeCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.util_GrouperUtil_objectHasAttributeCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.messaging_GrouperBuiltinMessagingSystem_messageCache.name = edu.internet2.middleware.grouper.messaging.GrouperBuiltinMessagingSystem.messageCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.messaging_GrouperBuiltinMessagingSystem_messageCache.maxElementsInMemory = 100

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.messaging_GrouperBuiltinMessagingSystem_messageCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.messaging_GrouperBuiltinMessagingSystem_messageCache.timeToIdleSeconds = 60

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.messaging_GrouperBuiltinMessagingSystem_messageCache.timeToLiveSeconds = 60

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.messaging_GrouperBuiltinMessagingSystem_messageCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.messaging_GrouperBuiltinMessagingSystem_messageCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.finder_AttributeDefFinder_attributeDefFinderCache.name = edu.internet2.middleware.grouper.attr.finder.AttributeDefFinder.attributeDefFinderCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.finder_AttributeDefFinder_attributeDefFinderCache.maxElementsInMemory = 10000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.finder_AttributeDefFinder_attributeDefFinderCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.finder_AttributeDefFinder_attributeDefFinderCache.timeToIdleSeconds = 60

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.finder_AttributeDefFinder_attributeDefFinderCache.timeToLiveSeconds = 60

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.finder_AttributeDefFinder_attributeDefFinderCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.finder_AttributeDefFinder_attributeDefFinderCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.grouper_GroupFinder_groupCache.name = edu.internet2.middleware.grouper.GroupFinder.groupCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.grouper_GroupFinder_groupCache.maxElementsInMemory = 10000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.grouper_GroupFinder_groupCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.grouper_GroupFinder_groupCache.timeToIdleSeconds = 60

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.grouper_GroupFinder_groupCache.timeToLiveSeconds = 60

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.grouper_GroupFinder_groupCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.grouper_GroupFinder_groupCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.grouper_GroupFinder_groupFlashCache.name = edu.internet2.middleware.grouper.GroupFinder.groupFlashCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.grouper_GroupFinder_groupFlashCache.maxElementsInMemory = 10000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.grouper_GroupFinder_groupFlashCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.grouper_GroupFinder_groupFlashCache.timeToIdleSeconds = 5

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.grouper_GroupFinder_groupFlashCache.timeToLiveSeconds = 5

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.grouper_GroupFinder_groupFlashCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.grouper_GroupFinder_groupFlashCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.grouper_StemFinder_stemFlashCache.name = edu.internet2.middleware.grouper.StemFinder.stemFlashCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.grouper_StemFinder_stemFlashCache.maxElementsInMemory = 10000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.grouper_StemFinder_stemFlashCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.grouper_StemFinder_stemFlashCache.timeToIdleSeconds = 5

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.grouper_StemFinder_stemFlashCache.timeToLiveSeconds = 5

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.grouper_StemFinder_stemFlashCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.grouper_StemFinder_stemFlashCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.hib3_Hib3MemberDAO_memberFlashCache.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3MemberDAO.memberFlashCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.hib3_Hib3MemberDAO_memberFlashCache.maxElementsInMemory = 10000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.hib3_Hib3MemberDAO_memberFlashCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.hib3_Hib3MemberDAO_memberFlashCache.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.hib3_Hib3MemberDAO_memberFlashCache.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.hib3_Hib3MemberDAO_memberFlashCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.hib3_Hib3MemberDAO_memberFlashCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.hib3_Hib3AttributeAssignActionDAO_attributeAssignActionFlashCache.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3AttributeAssignActionDAO.attributeAssignActionFlashCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.hib3_Hib3AttributeAssignActionDAO_attributeAssignActionFlashCache.maxElementsInMemory = 10000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.hib3_Hib3AttributeAssignActionDAO_attributeAssignActionFlashCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.hib3_Hib3AttributeAssignActionDAO_attributeAssignActionFlashCache.timeToIdleSeconds = 5

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.hib3_Hib3AttributeAssignActionDAO_attributeAssignActionFlashCache.timeToLiveSeconds = 5

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.hib3_Hib3AttributeAssignActionDAO_attributeAssignActionFlashCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.hib3_Hib3AttributeAssignActionDAO_attributeAssignActionFlashCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.finder_AttributeDefFinder_attributeDefFinderFlashCache.name = edu.internet2.middleware.grouper.attr.finder.AttributeDefFinder.attributeDefFinderFlashCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.finder_AttributeDefFinder_attributeDefFinderFlashCache.maxElementsInMemory = 10000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.finder_AttributeDefFinder_attributeDefFinderFlashCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.finder_AttributeDefFinder_attributeDefFinderFlashCache.timeToIdleSeconds = 5

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.finder_AttributeDefFinder_attributeDefFinderFlashCache.timeToLiveSeconds = 5

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.finder_AttributeDefFinder_attributeDefFinderFlashCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.finder_AttributeDefFinder_attributeDefFinderFlashCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.finder_AttributeDefNameFinder_attributeDefNameFinderFlashCache.name = edu.internet2.middleware.grouper.attr.finder.AttributeDefNameFinder.attributeDefNameFinderFlashCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.finder_AttributeDefNameFinder_attributeDefNameFinderFlashCache.maxElementsInMemory = 10000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.finder_AttributeDefNameFinder_attributeDefNameFinderFlashCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.finder_AttributeDefNameFinder_attributeDefNameFinderFlashCache.timeToIdleSeconds = 5

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.finder_AttributeDefNameFinder_attributeDefNameFinderFlashCache.timeToLiveSeconds = 5

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.finder_AttributeDefNameFinder_attributeDefNameFinderFlashCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.finder_AttributeDefNameFinder_attributeDefNameFinderFlashCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.finder_AttributeDefNameFinder_attributeDefNameFinderCache.name = edu.internet2.middleware.grouper.attr.finder.AttributeDefNameFinder.attributeDefNameFinderCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.finder_AttributeDefNameFinder_attributeDefNameFinderCache.maxElementsInMemory = 10000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.finder_AttributeDefNameFinder_attributeDefNameFinderCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.finder_AttributeDefNameFinder_attributeDefNameFinderCache.timeToIdleSeconds = 60

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.finder_AttributeDefNameFinder_attributeDefNameFinderCache.timeToLiveSeconds = 60

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.finder_AttributeDefNameFinder_attributeDefNameFinderCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.finder_AttributeDefNameFinder_attributeDefNameFinderCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.hib3_Hib3AttributeAssignDAO_attributeAssignFlashCache.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3AttributeAssignDAO.attributeAssignFlashCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.hib3_Hib3AttributeAssignDAO_attributeAssignFlashCache.maxElementsInMemory = 10000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.hib3_Hib3AttributeAssignDAO_attributeAssignFlashCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.hib3_Hib3AttributeAssignDAO_attributeAssignFlashCache.timeToIdleSeconds = 5

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.hib3_Hib3AttributeAssignDAO_attributeAssignFlashCache.timeToLiveSeconds = 5

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.hib3_Hib3AttributeAssignDAO_attributeAssignFlashCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.hib3_Hib3AttributeAssignDAO_attributeAssignFlashCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.examples_MembershipOneInFolderMaxHook_membershipOneAttribute.name = edu.internet2.middleware.grouper.hooks.examples.MembershipOneInFolderMaxHook.membershipOneAttribute

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.examples_MembershipOneInFolderMaxHook_membershipOneAttribute.maxElementsInMemory = 5000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.examples_MembershipOneInFolderMaxHook_membershipOneAttribute.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.examples_MembershipOneInFolderMaxHook_membershipOneAttribute.timeToIdleSeconds = 60

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.examples_MembershipOneInFolderMaxHook_membershipOneAttribute.timeToLiveSeconds = 60

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.examples_MembershipOneInFolderMaxHook_membershipOneAttribute.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.examples_MembershipOneInFolderMaxHook_membershipOneAttribute.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.externalSubjects_ExternalSubjectConfig_configCache.name = edu.internet2.middleware.grouper.externalSubjects.ExternalSubjectConfig.configCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.externalSubjects_ExternalSubjectConfig_configCache.maxElementsInMemory = 50

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.externalSubjects_ExternalSubjectConfig_configCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.externalSubjects_ExternalSubjectConfig_configCache.timeToIdleSeconds = 300

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.externalSubjects_ExternalSubjectConfig_configCache.timeToLiveSeconds = 300

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.externalSubjects_ExternalSubjectConfig_configCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.externalSubjects_ExternalSubjectConfig_configCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.externalSubjects_ExternalSubjectConfig_autoaddConfigCache.name = edu.internet2.middleware.grouper.externalSubjects.ExternalSubjectConfig.autoaddConfigCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.externalSubjects_ExternalSubjectConfig_autoaddConfigCache.maxElementsInMemory = 50

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.externalSubjects_ExternalSubjectConfig_autoaddConfigCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.externalSubjects_ExternalSubjectConfig_autoaddConfigCache.timeToIdleSeconds = 300

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.externalSubjects_ExternalSubjectConfig_autoaddConfigCache.timeToLiveSeconds = 300

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.externalSubjects_ExternalSubjectConfig_autoaddConfigCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.externalSubjects_ExternalSubjectConfig_autoaddConfigCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.grouper_GroupTypeFinder_typeCache.name = edu.internet2.middleware.grouper.GroupTypeFinder.typeCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.grouper_GroupTypeFinder_typeCache.maxElementsInMemory = 10000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.grouper_GroupTypeFinder_typeCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.grouper_GroupTypeFinder_typeCache.timeToIdleSeconds = 600

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.grouper_GroupTypeFinder_typeCache.timeToLiveSeconds = 600

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.grouper_GroupTypeFinder_typeCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.grouper_GroupTypeFinder_typeCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.grouper_GroupTypeFinder_legacyAttributes.name = edu.internet2.middleware.grouper.GroupTypeFinder.legacyAttributes

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.grouper_GroupTypeFinder_legacyAttributes.maxElementsInMemory = 10000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.grouper_GroupTypeFinder_legacyAttributes.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.grouper_GroupTypeFinder_legacyAttributes.timeToIdleSeconds = 600

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.grouper_GroupTypeFinder_legacyAttributes.timeToLiveSeconds = 600

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.grouper_GroupTypeFinder_legacyAttributes.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.grouper_GroupTypeFinder_legacyAttributes.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.grouper_GroupTypeFinder_fieldIdToTypeIdCache.name = edu.internet2.middleware.grouper.GroupTypeFinder.fieldIdToTypeIdCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.grouper_GroupTypeFinder_fieldIdToTypeIdCache.maxElementsInMemory = 10000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.grouper_GroupTypeFinder_fieldIdToTypeIdCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.grouper_GroupTypeFinder_fieldIdToTypeIdCache.timeToIdleSeconds = 600

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.grouper_GroupTypeFinder_fieldIdToTypeIdCache.timeToLiveSeconds = 600

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.grouper_GroupTypeFinder_fieldIdToTypeIdCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.grouper_GroupTypeFinder_fieldIdToTypeIdCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.beans_HooksContext_groupNameToGroupCache.name = edu.internet2.middleware.grouper.hooks.beans.HooksContext.groupNameToGroupCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.beans_HooksContext_groupNameToGroupCache.maxElementsInMemory = 2000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.beans_HooksContext_groupNameToGroupCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.beans_HooksContext_groupNameToGroupCache.timeToIdleSeconds = 300

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.beans_HooksContext_groupNameToGroupCache.timeToLiveSeconds = 300

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.beans_HooksContext_groupNameToGroupCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.beans_HooksContext_groupNameToGroupCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.beans_HooksContext_subjectInGroupCache.name = edu.internet2.middleware.grouper.hooks.beans.HooksContext.subjectInGroupCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.beans_HooksContext_subjectInGroupCache.maxElementsInMemory = 2000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.beans_HooksContext_subjectInGroupCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.beans_HooksContext_subjectInGroupCache.timeToIdleSeconds = 300

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.beans_HooksContext_subjectInGroupCache.timeToLiveSeconds = 300

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.beans_HooksContext_subjectInGroupCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.beans_HooksContext_subjectInGroupCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.grouper_FieldFinder_fieldCache.name = edu.internet2.middleware.grouper.FieldFinder.fieldCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.grouper_FieldFinder_fieldCache.maxElementsInMemory = 10000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.grouper_FieldFinder_fieldCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.grouper_FieldFinder_fieldCache.timeToIdleSeconds = 600

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.grouper_FieldFinder_fieldCache.timeToLiveSeconds = 600

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.grouper_FieldFinder_fieldCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.grouper_FieldFinder_fieldCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.util_GrouperUtil_declaredMethodsCache.name = edu.internet2.middleware.grouper.util.GrouperUtil.declaredMethodsCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.util_GrouperUtil_declaredMethodsCache.maxElementsInMemory = 2000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.util_GrouperUtil_declaredMethodsCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.util_GrouperUtil_declaredMethodsCache.timeToIdleSeconds = 86400

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.util_GrouperUtil_declaredMethodsCache.timeToLiveSeconds = 86400

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.util_GrouperUtil_declaredMethodsCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.util_GrouperUtil_declaredMethodsCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.changeLog_ChangeLogTypeFinder_typeCache.name = edu.internet2.middleware.grouper.changeLog.ChangeLogTypeFinder.typeCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.changeLog_ChangeLogTypeFinder_typeCache.maxElementsInMemory = 10000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.changeLog_ChangeLogTypeFinder_typeCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.changeLog_ChangeLogTypeFinder_typeCache.timeToIdleSeconds = 600

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.changeLog_ChangeLogTypeFinder_typeCache.timeToLiveSeconds = 600

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.changeLog_ChangeLogTypeFinder_typeCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.changeLog_ChangeLogTypeFinder_typeCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.hib3_Hib3GroupDAO_exists.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3GroupDAO.exists

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.hib3_Hib3GroupDAO_exists.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.hib3_Hib3GroupDAO_exists.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.hib3_Hib3GroupDAO_exists.timeToIdleSeconds = 30

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.hib3_Hib3GroupDAO_exists.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.hib3_Hib3GroupDAO_exists.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.hib3_Hib3GroupDAO_exists.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.rules_RuleEngine_ruleEngine.name = edu.internet2.middleware.grouper.rules.RuleEngine.ruleEngine

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.rules_RuleEngine_ruleEngine.maxElementsInMemory = 100

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.rules_RuleEngine_ruleEngine.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.rules_RuleEngine_ruleEngine.timeToIdleSeconds = 300

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.rules_RuleEngine_ruleEngine.timeToLiveSeconds = 300

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.rules_RuleEngine_ruleEngine.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.rules_RuleEngine_ruleEngine.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.rules_RuleEngine_hasAccessToElApi.name = edu.internet2.middleware.grouper.rules.RuleEngine.hasAccessToElApi

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.rules_RuleEngine_hasAccessToElApi.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.rules_RuleEngine_hasAccessToElApi.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.rules_RuleEngine_hasAccessToElApi.timeToIdleSeconds = 150

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.rules_RuleEngine_hasAccessToElApi.timeToLiveSeconds = 150

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.rules_RuleEngine_hasAccessToElApi.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.rules_RuleEngine_hasAccessToElApi.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.audit_AuditTypeFinder_typeCache.name = edu.internet2.middleware.grouper.audit.AuditTypeFinder.typeCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.audit_AuditTypeFinder_typeCache.maxElementsInMemory = 10000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.audit_AuditTypeFinder_typeCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.audit_AuditTypeFinder_typeCache.timeToIdleSeconds = 600

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.audit_AuditTypeFinder_typeCache.timeToLiveSeconds = 600

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.audit_AuditTypeFinder_typeCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.audit_AuditTypeFinder_typeCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.assign_AttributeAssignBaseDelegate_objectHasAttributeCache.name = edu.internet2.middleware.grouper.attr.assign.AttributeAssignBaseDelegate.objectHasAttributeCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.assign_AttributeAssignBaseDelegate_objectHasAttributeCache.maxElementsInMemory = 5000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.assign_AttributeAssignBaseDelegate_objectHasAttributeCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.assign_AttributeAssignBaseDelegate_objectHasAttributeCache.timeToIdleSeconds = 60

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.assign_AttributeAssignBaseDelegate_objectHasAttributeCache.timeToLiveSeconds = 60

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.assign_AttributeAssignBaseDelegate_objectHasAttributeCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.assign_AttributeAssignBaseDelegate_objectHasAttributeCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.grouper_TestField_testFieldCache.name = edu.internet2.middleware.grouper.TestField.testFieldCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.grouper_TestField_testFieldCache.maxElementsInMemory = 10000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.grouper_TestField_testFieldCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.grouper_TestField_testFieldCache.timeToIdleSeconds = 3

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.grouper_TestField_testFieldCache.timeToLiveSeconds = 3

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.grouper_TestField_testFieldCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.grouper_TestField_testFieldCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.util_GrouperUtil_fieldSetCache.name = edu.internet2.middleware.grouper.util.GrouperUtil.fieldSetCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.util_GrouperUtil_fieldSetCache.maxElementsInMemory = 2000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.util_GrouperUtil_fieldSetCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.util_GrouperUtil_fieldSetCache.timeToIdleSeconds = 86400

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.util_GrouperUtil_fieldSetCache.timeToLiveSeconds = 86400

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.util_GrouperUtil_fieldSetCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.util_GrouperUtil_fieldSetCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.util_GrouperCacheTest_testCache.name = edu.internet2.middleware.grouper.util.GrouperCacheTest.testCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.util_GrouperCacheTest_testCache.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.util_GrouperCacheTest_testCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.util_GrouperCacheTest_testCache.timeToIdleSeconds = 1

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.util_GrouperCacheTest_testCache.timeToLiveSeconds = 1

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.util_GrouperCacheTest_testCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.util_GrouperCacheTest_testCache.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.deprovisioning_GrouperDeprovisioningOverallConfiguration_overallConfigCache.name = edu.internet2.middleware.grouper.app.deprovisioning.GrouperDeprovisioningOverallConfiguration.overallConfigCache

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.deprovisioning_GrouperDeprovisioningOverallConfiguration_overallConfigCache.maxElementsInMemory = 10000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.deprovisioning_GrouperDeprovisioningOverallConfiguration_overallConfigCache.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.deprovisioning_GrouperDeprovisioningOverallConfiguration_overallConfigCache.timeToIdleSeconds = 120

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.deprovisioning_GrouperDeprovisioningOverallConfiguration_overallConfigCache.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.deprovisioning_GrouperDeprovisioningOverallConfiguration_overallConfigCache.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.deprovisioning_GrouperDeprovisioningOverallConfiguration_overallConfigCache.statistics = false



# name of cache referred in java
# {valueType: "string", required: true}
cache.name.stem_StemSet.name = edu.internet2.middleware.grouper.stem.StemSet

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.stem_StemSet.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.stem_StemSet.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.stem_StemSet.timeToIdleSeconds = 120

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.stem_StemSet.timeToLiveSeconds = 120

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.stem_StemSet.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.stem_StemSet.statistics = false




# name of cache referred in java
# {valueType: "string", required: true}
cache.name.messaging_GrouperMessageHibernate.name = edu.internet2.middleware.grouper.messaging.GrouperMessageHibernate

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.messaging_GrouperMessageHibernate.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.messaging_GrouperMessageHibernate.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.messaging_GrouperMessageHibernate.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.messaging_GrouperMessageHibernate.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.messaging_GrouperMessageHibernate.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.messaging_GrouperMessageHibernate.statistics = false





# name of cache referred in java
# {valueType: "string", required: true}
cache.name.tableIndex_TableIndex.name = edu.internet2.middleware.grouper.tableIndex.TableIndex

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.tableIndex_TableIndex.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.tableIndex_TableIndex.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.tableIndex_TableIndex.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.tableIndex_TableIndex.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.tableIndex_TableIndex.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.tableIndex_TableIndex.statistics = false




# name of cache referred in java
# {valueType: "string", required: true}
cache.name.cfg_dbConfig_GrouperConfigHibernate.name = edu.internet2.middleware.grouper.cfg.dbConfig.GrouperConfigHibernate

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.cfg_dbConfig_GrouperConfigHibernate.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.cfg_dbConfig_GrouperConfigHibernate.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.cfg_dbConfig_GrouperConfigHibernate.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.cfg_dbConfig_GrouperConfigHibernate.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.cfg_dbConfig_GrouperConfigHibernate.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.cfg_dbConfig_GrouperConfigHibernate.statistics = false





# name of cache referred in java
# {valueType: "string", required: true}
cache.name.hib3_Hib3GroupDAO_FindByNameSecure.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3GroupDAO.FindByNameSecure

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.hib3_Hib3GroupDAO_FindByNameSecure.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.hib3_Hib3GroupDAO_FindByNameSecure.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.hib3_Hib3GroupDAO_FindByNameSecure.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.hib3_Hib3GroupDAO_FindByNameSecure.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.hib3_Hib3GroupDAO_FindByNameSecure.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.hib3_Hib3GroupDAO_FindByNameSecure.statistics = false



# name of cache referred in java
# {valueType: "string", required: true}
cache.name.tableSync_GcGrouperSync.name = edu.internet2.middleware.grouperClient.jdbc.tableSync.GcGrouperSync

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.tableSync_GcGrouperSync.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.tableSync_GcGrouperSync.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.tableSync_GcGrouperSync.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.tableSync_GcGrouperSync.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.tableSync_GcGrouperSync.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.tableSync_GcGrouperSync.statistics = false





# name of cache referred in java
# {valueType: "string", required: true}
cache.name.tableSync_GcGrouperSyncGroup.name = edu.internet2.middleware.grouperClient.jdbc.tableSync.GcGrouperSyncGroup

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.tableSync_GcGrouperSyncGroup.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.tableSync_GcGrouperSyncGroup.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.tableSync_GcGrouperSyncGroup.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.tableSync_GcGrouperSyncGroup.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.tableSync_GcGrouperSyncGroup.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.tableSync_GcGrouperSyncGroup.statistics = false





# name of cache referred in java
# {valueType: "string", required: true}
cache.name.tableSync_GcGrouperSyncJob.name = edu.internet2.middleware.grouperClient.jdbc.tableSync.GcGrouperSyncJob

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.tableSync_GcGrouperSyncJob.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.tableSync_GcGrouperSyncJob.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.tableSync_GcGrouperSyncJob.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.tableSync_GcGrouperSyncJob.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.tableSync_GcGrouperSyncJob.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.tableSync_GcGrouperSyncJob.statistics = false






# name of cache referred in java
# {valueType: "string", required: true}
cache.name.tableSync_GcGrouperSyncLog.name = edu.internet2.middleware.grouperClient.jdbc.tableSync.GcGrouperSyncLog

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.tableSync_GcGrouperSyncLog.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.tableSync_GcGrouperSyncLog.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.tableSync_GcGrouperSyncLog.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.tableSync_GcGrouperSyncLog.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.tableSync_GcGrouperSyncLog.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.tableSync_GcGrouperSyncLog.statistics = false






# name of cache referred in java
# {valueType: "string", required: true}
cache.name.tableSync_GcGrouperSyncMember.name = edu.internet2.middleware.grouperClient.jdbc.tableSync.GcGrouperSyncMember

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.tableSync_GcGrouperSyncMember.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.tableSync_GcGrouperSyncMember.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.tableSync_GcGrouperSyncMember.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.tableSync_GcGrouperSyncMember.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.tableSync_GcGrouperSyncMember.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.tableSync_GcGrouperSyncMember.statistics = false




# name of cache referred in java
# {valueType: "string", required: true}
cache.name.tableSync_GcGrouperSyncMembership.name = edu.internet2.middleware.grouperClient.jdbc.tableSync.GcGrouperSyncMembership

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.tableSync_GcGrouperSyncMembership.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.tableSync_GcGrouperSyncMembership.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.tableSync_GcGrouperSyncMembership.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.tableSync_GcGrouperSyncMembership.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.tableSync_GcGrouperSyncMembership.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.tableSync_GcGrouperSyncMembership.statistics = false




# name of cache referred in java
# {valueType: "string", required: true}
cache.name.hib3_Hib3AttributeAssignDAO_FindByAttributeTypeDefNameId.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3AttributeAssignDAO.FindByAttributeTypeDefNameId

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.hib3_Hib3AttributeAssignDAO_FindByAttributeTypeDefNameId.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.hib3_Hib3AttributeAssignDAO_FindByAttributeTypeDefNameId.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.hib3_Hib3AttributeAssignDAO_FindByAttributeTypeDefNameId.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.hib3_Hib3AttributeAssignDAO_FindByAttributeTypeDefNameId.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.hib3_Hib3AttributeAssignDAO_FindByAttributeTypeDefNameId.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.hib3_Hib3AttributeAssignDAO_FindByAttributeTypeDefNameId.statistics = false




# name of cache referred in java
# {valueType: "string", required: true}
cache.name.hib3_Hib3AttributeAssignValueDAO_FindByAttributeAssignIds.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3AttributeAssignValueDAO.FindByAttributeAssignIds

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.hib3_Hib3AttributeAssignValueDAO_FindByAttributeAssignIds.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.hib3_Hib3AttributeAssignValueDAO_FindByAttributeAssignIds.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.hib3_Hib3AttributeAssignValueDAO_FindByAttributeAssignIds.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.hib3_Hib3AttributeAssignValueDAO_FindByAttributeAssignIds.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.hib3_Hib3AttributeAssignValueDAO_FindByAttributeAssignIds.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.hib3_Hib3AttributeAssignValueDAO_FindByAttributeAssignIds.statistics = false





# name of cache referred in java
# {valueType: "string", required: true}
cache.name.hib3_Hib3MemberDAO_FindByUuidsSecure.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3MemberDAO.FindByUuidsSecure

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.hib3_Hib3MemberDAO_FindByUuidsSecure.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.hib3_Hib3MemberDAO_FindByUuidsSecure.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.hib3_Hib3MemberDAO_FindByUuidsSecure.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.hib3_Hib3MemberDAO_FindByUuidsSecure.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.hib3_Hib3MemberDAO_FindByUuidsSecure.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.hib3_Hib3MemberDAO_FindByUuidsSecure.statistics = false



# name of cache referred in java
# {valueType: "string", required: true}
cache.name.hib3_Hib3PITMembershipDAO_FindBySourceId.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3PITMembershipDAO.FindBySourceId

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.hib3_Hib3PITMembershipDAO_FindBySourceId.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.hib3_Hib3PITMembershipDAO_FindBySourceId.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.hib3_Hib3PITMembershipDAO_FindBySourceId.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.hib3_Hib3PITMembershipDAO_FindBySourceId.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.hib3_Hib3PITMembershipDAO_FindBySourceId.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.hib3_Hib3PITMembershipDAO_FindBySourceId.statistics = false




# name of cache referred in java
# {valueType: "string", required: true}
cache.name.hib3_Hib3StemDAO_FindByUuids.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3StemDAO.FindByUuids

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.hib3_Hib3StemDAO_FindByUuids.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.hib3_Hib3StemDAO_FindByUuids.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.hib3_Hib3StemDAO_FindByUuids.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.hib3_Hib3StemDAO_FindByUuids.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.hib3_Hib3StemDAO_FindByUuids.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.hib3_Hib3StemDAO_FindByUuids.statistics = false


# name of cache referred in java
# {valueType: "string", required: true}
cache.name.hib3_Hib3PITGroupDAO_FindByIds.name = edu.internet2.middleware.grouper.internal.dao.hib3.Hib3PITGroupDAO.FindByIds

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.hib3_Hib3PITGroupDAO_FindByIds.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.hib3_Hib3PITGroupDAO_FindByIds.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.hib3_Hib3PITGroupDAO_FindByIds.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.hib3_Hib3PITGroupDAO_FindByIds.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.hib3_Hib3PITGroupDAO_FindByIds.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.hib3_Hib3PITGroupDAO_FindByIds.statistics = false



# name of cache referred in java
# {valueType: "string", required: true}
cache.name.file_GrouperFile.name = edu.internet2.middleware.grouper.file.GrouperFile

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.file_GrouperFile.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.file_GrouperFile.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.file_GrouperFile.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.file_GrouperFile.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.file_GrouperFile.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.file_GrouperFile.statistics = false



# name of cache referred in java
# {valueType: "string", required: true}
cache.name.pit_PITGrouperConfigHibernate.name = edu.internet2.middleware.grouper.pit.PITGrouperConfigHibernate

# Sets the maximum number of objects that will be created in memory
# {valueType: "integer", required: true}
cache.name.pit_PITGrouperConfigHibernate.maxElementsInMemory = 1000

# Sets whether elements are eternal. If eternal,  timeouts are ignored and the element is never expired.
# {valueType: "boolean", required: true}
cache.name.pit_PITGrouperConfigHibernate.eternal = false

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITGrouperConfigHibernate.timeToIdleSeconds = 10

# Sets the time to live for an element before it expires. Is only used if the element is not eternal.  TTL is now - creation time.
# {valueType: "integer", required: true}
cache.name.pit_PITGrouperConfigHibernate.timeToLiveSeconds = 10

# Sets whether elements can overflow to disk when the in-memory cache has reached the maxInMemory limit.
# {valueType: "boolean", required: true}
cache.name.pit_PITGrouperConfigHibernate.overflowToDisk = false

# If stats on caches should be kept
# {valueType: "boolean", required: true}
cache.name.pit_PITGrouperConfigHibernate.statistics = false