diff --git a/src/main/java/org/springframework/data/gemfire/DiskStoreFactoryBean.java b/src/main/java/org/springframework/data/gemfire/DiskStoreFactoryBean.java
new file mode 100644
index 00000000..6684727b
--- /dev/null
+++ b/src/main/java/org/springframework/data/gemfire/DiskStoreFactoryBean.java
@@ -0,0 +1,172 @@
+/*
+ * Copyright 2010-2011 the original author or authors.
+ *
+ * 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.
+ */
+
+package org.springframework.data.gemfire;
+
+import java.io.File;
+import java.util.List;
+
+import org.springframework.beans.factory.BeanNameAware;
+import org.springframework.beans.factory.FactoryBean;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.util.Assert;
+import org.springframework.util.CollectionUtils;
+
+import com.gemstone.gemfire.cache.DiskStore;
+import com.gemstone.gemfire.cache.DiskStoreFactory;
+import com.gemstone.gemfire.cache.GemFireCache;
+
+/**
+ * FactoryBean for creating a DiskStore
+ * @author David Turanski
+ */
+public class DiskStoreFactoryBean implements FactoryBean<DiskStore>, InitializingBean, BeanNameAware {
+
+	private DiskStoreFactory diskStoreFactory;
+
+	private Boolean autoCompact;
+
+	private Boolean allowForceCompaction;
+
+	private Integer maxOplogSize;
+
+	private Integer timeInterval;
+
+	private Integer queueSize;
+
+	private Integer compactionThreshold;
+
+	private Integer writeBufferSize;
+
+	private GemFireCache cache;
+
+	private String name;
+
+	private List<DiskDir> diskDirs;
+
+	@Override
+	public DiskStore getObject() throws Exception {
+		return diskStoreFactory.create(name == null ? DiskStoreFactory.DEFAULT_DISK_STORE_NAME : name);
+	}
+
+	@Override
+	public Class<?> getObjectType() {
+		return DiskStore.class;
+	}
+
+	@Override
+	public boolean isSingleton() {
+		return true;
+	}
+
+	@Override
+	public void afterPropertiesSet() throws Exception {
+		Assert.notNull(cache, "Cache property must be set");
+		diskStoreFactory = cache.createDiskStoreFactory();
+
+		if (allowForceCompaction != null) {
+			diskStoreFactory.setAllowForceCompaction(allowForceCompaction);
+		}
+		if (compactionThreshold != null) {
+			diskStoreFactory.setCompactionThreshold(compactionThreshold);
+		}
+		if (autoCompact != null) {
+			diskStoreFactory.setAutoCompact(autoCompact);
+		}
+		if (queueSize != null) {
+			diskStoreFactory.setQueueSize(queueSize);
+		}
+		if (writeBufferSize != null) {
+			diskStoreFactory.setWriteBufferSize(writeBufferSize);
+		}
+		if (timeInterval != null) {
+			diskStoreFactory.setTimeInterval(timeInterval);
+		}
+		if (maxOplogSize != null) {
+			diskStoreFactory.setMaxOplogSize(maxOplogSize);
+		}
+
+		if (!CollectionUtils.isEmpty(diskDirs)) {
+			File[] diskDirFiles = new File[diskDirs.size()];
+			int[] diskDirSizes = new int[diskDirs.size()];
+			for (int i = 0; i < diskDirs.size(); i++) {
+				DiskDir diskDir = diskDirs.get(i);
+				diskDirFiles[i] = new File(diskDir.location);
+				diskDirSizes[i] = diskDir.maxSize == null ? DiskStoreFactory.DEFAULT_DISK_DIR_SIZE : diskDir.maxSize;
+			}
+			diskStoreFactory.setDiskDirsAndSizes(diskDirFiles, diskDirSizes);
+		}
+
+	}
+
+	public void setCache(GemFireCache cache) {
+		this.cache = cache;
+	}
+
+	public void setAutoCompact(Boolean autoCompact) {
+		this.autoCompact = autoCompact;
+	}
+
+	public void setAllowForceCompaction(Boolean allowForceCompaction) {
+		this.allowForceCompaction = allowForceCompaction;
+	}
+
+	public void setMaxOplogSize(Integer maxOplogSize) {
+		this.maxOplogSize = maxOplogSize;
+	}
+
+	public void setTimeInterval(Integer timeInterval) {
+		this.timeInterval = timeInterval;
+	}
+
+	public void setQueueSize(Integer queueSize) {
+		this.queueSize = queueSize;
+	}
+
+	public void setCompactionThreshold(Integer compactionThreshold) {
+		this.compactionThreshold = compactionThreshold;
+	}
+
+	public void setWriteBufferSize(Integer writeBufferSize) {
+		this.writeBufferSize = writeBufferSize;
+	}
+
+	public void setDiskDirs(List<DiskDir> diskDirs) {
+		this.diskDirs = diskDirs;
+	}
+
+	@Override
+	public void setBeanName(String name) {
+		this.name = name;
+	}
+
+	public static class DiskDir {
+		final String location;
+
+		final Integer maxSize;
+
+		public DiskDir(String location, int maxSize) {
+			this.location = location;
+			this.maxSize = maxSize;
+		}
+
+		public DiskDir(String location) {
+			this.location = location;
+			this.maxSize = null;
+		}
+	}
+
+}
diff --git a/src/main/java/org/springframework/data/gemfire/RegionFactoryBean.java b/src/main/java/org/springframework/data/gemfire/RegionFactoryBean.java
index f81c2909..51a4438b 100644
--- a/src/main/java/org/springframework/data/gemfire/RegionFactoryBean.java
+++ b/src/main/java/org/springframework/data/gemfire/RegionFactoryBean.java
@@ -29,7 +29,6 @@ import org.springframework.util.ObjectUtils;
 import org.springframework.util.ReflectionUtils;
 
 import com.gemstone.gemfire.cache.AttributesFactory;
-import com.gemstone.gemfire.cache.AttributesMutator;
 import com.gemstone.gemfire.cache.Cache;
 import com.gemstone.gemfire.cache.CacheClosedException;
 import com.gemstone.gemfire.cache.CacheListener;
@@ -43,11 +42,14 @@ import com.gemstone.gemfire.cache.RegionFactory;
 import com.gemstone.gemfire.cache.Scope;
 
 /**
- * FactoryBean for creating generic GemFire {@link Region}s. Will try to first locate the region (by name)
- * and, in case none if found, proceed to creating one using the given settings.
+ * FactoryBean for creating generic GemFire {@link Region}s. Will try to first
+ * locate the region (by name) and, in case none if found, proceed to creating
+ * one using the given settings.
  * 
- * Note that this factory bean allows for very flexible creation of GemFire {@link Region}. For "client" regions
- * however, see {@link ClientRegionFactoryBean} which offers easier configuration and defaults.
+ * Note that this factory bean allows for very flexible creation of GemFire
+ * {@link Region}. For "client" regions however, see
+ * {@link ClientRegionFactoryBean} which offers easier configuration and
+ * defaults.
  * 
  * @author Costin Leau
  */
@@ -56,18 +58,26 @@ public class RegionFactoryBean<K, V> extends RegionLookupFactoryBean<K, V> imple
 	protected final Log log = LogFactory.getLog(getClass());
 
 	private boolean destroy = false;
+
 	private boolean close = true;
+
 	private Resource snapshot;
 
 	private CacheListener<K, V> cacheListeners[];
-	private CacheLoader<K, V> cacheLoader;
-	private CacheWriter<K, V> cacheWriter;
-	private RegionAttributes<K, V> attributes;
-	private Scope scope;
-	private DataPolicy dataPolicy;
-	private Region<K, V> region;
-	private List<Region<?, ?>> subRegions;
 
+	private CacheLoader<K, V> cacheLoader;
+
+	private CacheWriter<K, V> cacheWriter;
+
+	private RegionAttributes<K, V> attributes;
+
+	private Scope scope;
+
+	private DataPolicy dataPolicy;
+
+	private Region<K, V> region;
+
+	private List<Region<?, ?>> subRegions;
 
 	@Override
 	public void afterPropertiesSet() throws Exception {
@@ -85,9 +95,8 @@ public class RegionFactoryBean<K, V> extends RegionLookupFactoryBean<K, V> imple
 		if (attributes != null)
 			AttributesFactory.validateAttributes(attributes);
 
-		final RegionFactory<K, V> regionFactory = (attributes != null ? c.createRegionFactory(attributes)
-				: c.<K, V> createRegionFactory());
-		
+		final RegionFactory<K, V> regionFactory = (attributes != null ? c.createRegionFactory(attributes) : c
+				.<K, V> createRegionFactory());
 
 		if (!ObjectUtils.isEmpty(cacheListeners)) {
 			for (CacheListener<K, V> listener : cacheListeners) {
@@ -113,13 +122,13 @@ public class RegionFactoryBean<K, V> extends RegionLookupFactoryBean<K, V> imple
 
 		// get underlying AttributesFactory
 		postProcess(findAttrFactory(regionFactory));
-        
+
 		Region<K, V> reg = regionFactory.create(regionName);
 		log.info("Created new cache region [" + regionName + "]");
 		if (snapshot != null) {
 			reg.loadSnapshot(snapshot.getInputStream());
 		}
-		
+
 		if (subRegions != null) {
 			System.out.println("**********************************************" + subRegions.get(0));
 		}
@@ -134,24 +143,24 @@ public class RegionFactoryBean<K, V> extends RegionLookupFactoryBean<K, V> imple
 		return (AttributesFactory<K, V>) ReflectionUtils.getField(attrField, regionFactory);
 	}
 
-
 	/**
-	 * Post-process the attribute factory object used for configuring the region of this factory bean during the initialization process.
-	 * The object is already initialized and configured by the factory bean before this method
+	 * Post-process the attribute factory object used for configuring the region
+	 * of this factory bean during the initialization process. The object is
+	 * already initialized and configured by the factory bean before this method
 	 * is invoked.
 	 * 
 	 * @param attrFactory attribute factory
-	 * @deprecated as of GemFire 6.5, the use of {@link AttributesFactory} has been deprecated
+	 * @deprecated as of GemFire 6.5, the use of {@link AttributesFactory} has
+	 * been deprecated
 	 */
 	@Deprecated
 	protected void postProcess(AttributesFactory<K, V> attrFactory) {
 	}
 
-
 	/**
-	 * Post-process the region object for this factory bean during the initialization process.
-	 * The object is already initialized and configured by the factory bean before this method
-	 * is invoked.
+	 * Post-process the region object for this factory bean during the
+	 * initialization process. The object is already initialized and configured
+	 * by the factory bean before this method is invoked.
 	 * 
 	 * @param region
 	 */
@@ -159,13 +168,15 @@ public class RegionFactoryBean<K, V> extends RegionLookupFactoryBean<K, V> imple
 		// do nothing
 	}
 
+	@Override
 	public void destroy() throws Exception {
 		if (region != null) {
 			if (close) {
 				if (!region.getCache().isClosed()) {
 					try {
 						region.close();
-					} catch (CacheClosedException cce) {
+					}
+					catch (CacheClosedException cce) {
 						// nothing to see folks, move on.
 					}
 				}
@@ -178,9 +189,9 @@ public class RegionFactoryBean<K, V> extends RegionLookupFactoryBean<K, V> imple
 	}
 
 	/**
-	 * Indicates whether the region referred by this factory bean,
-	 * will be destroyed on shutdown (default false).
-	 * Note: destroy and close are mutually exclusive. Enabling one will automatically disable the other.
+	 * Indicates whether the region referred by this factory bean, will be
+	 * destroyed on shutdown (default false). Note: destroy and close are
+	 * mutually exclusive. Enabling one will automatically disable the other.
 	 * 
 	 * @param destroy whether or not to destroy the region
 	 * 
@@ -195,9 +206,9 @@ public class RegionFactoryBean<K, V> extends RegionLookupFactoryBean<K, V> imple
 	}
 
 	/**
-	 * Indicates whether the region referred by this factory bean,
-	 * will be closed on shutdown (default true).
-	 * Note: destroy and close are mutually exclusive. Enabling one will automatically disable the other.
+	 * Indicates whether the region referred by this factory bean, will be
+	 * closed on shutdown (default true). Note: destroy and close are mutually
+	 * exclusive. Enabling one will automatically disable the other.
 	 * 
 	 * @param close whether to close or not the region
 	 * @see #setDestroy(boolean)
@@ -210,9 +221,9 @@ public class RegionFactoryBean<K, V> extends RegionLookupFactoryBean<K, V> imple
 	}
 
 	/**
-	 * Sets the snapshots used for loading a newly <i>created</i> region.
-	 * That is, the snapshot will be used <i>only</i> when a new region is created - if the region
-	 * already exists, no loading will be performed.
+	 * Sets the snapshots used for loading a newly <i>created</i> region. That
+	 * is, the snapshot will be used <i>only</i> when a new region is created -
+	 * if the region already exists, no loading will be performed.
 	 * 
 	 * @see #setName(String)
 	 * @param snapshot the snapshot to set
@@ -222,9 +233,9 @@ public class RegionFactoryBean<K, V> extends RegionLookupFactoryBean<K, V> imple
 	}
 
 	/**
-	 * Sets the cache listeners used for the region used by this factory.
-	 * Used only when a new region is created.Overrides the settings
-	 * specified through {@link #setAttributes(RegionAttributes)}.
+	 * Sets the cache listeners used for the region used by this factory. Used
+	 * only when a new region is created.Overrides the settings specified
+	 * through {@link #setAttributes(RegionAttributes)}.
 	 * 
 	 * @param cacheListeners the cacheListeners to set on a newly created region
 	 */
@@ -237,11 +248,10 @@ public class RegionFactoryBean<K, V> extends RegionLookupFactoryBean<K, V> imple
 		this.subRegions = subRegions;
 	}
 
-
 	/**
-	 * Sets the cache loader used for the region used by this factory.
-	 * Used only when a new region is created.Overrides the settings
-	 * specified through {@link #setAttributes(RegionAttributes)}.
+	 * Sets the cache loader used for the region used by this factory. Used only
+	 * when a new region is created.Overrides the settings specified through
+	 * {@link #setAttributes(RegionAttributes)}.
 	 * 
 	 * @param cacheLoader the cacheLoader to set on a newly created region
 	 */
@@ -250,9 +260,9 @@ public class RegionFactoryBean<K, V> extends RegionLookupFactoryBean<K, V> imple
 	}
 
 	/**
-	 * Sets the cache writer used for the region used by this factory.
-	 * Used only when a new region is created. Overrides the settings
-	 * specified through {@link #setAttributes(RegionAttributes)}.
+	 * Sets the cache writer used for the region used by this factory. Used only
+	 * when a new region is created. Overrides the settings specified through
+	 * {@link #setAttributes(RegionAttributes)}.
 	 * 
 	 * @param cacheWriter the cacheWriter to set on a newly created region
 	 */
@@ -261,8 +271,8 @@ public class RegionFactoryBean<K, V> extends RegionLookupFactoryBean<K, V> imple
 	}
 
 	/**
-	 * Sets the data policy. Used only when a new region is created.
-	 * Overrides the settings specified through {@link #setAttributes(RegionAttributes)}.
+	 * Sets the data policy. Used only when a new region is created. Overrides
+	 * the settings specified through {@link #setAttributes(RegionAttributes)}.
 	 * 
 	 * @param dataPolicy the region data policy
 	 */
@@ -271,8 +281,8 @@ public class RegionFactoryBean<K, V> extends RegionLookupFactoryBean<K, V> imple
 	}
 
 	/**
-	 * Sets the region scope. Used only when a new region is created.
-	 * Overrides the settings specified through {@link #setAttributes(RegionAttributes)}.
+	 * Sets the region scope. Used only when a new region is created. Overrides
+	 * the settings specified through {@link #setAttributes(RegionAttributes)}.
 	 * 
 	 * @see Scope
 	 * @param scope the region scope
@@ -283,8 +293,8 @@ public class RegionFactoryBean<K, V> extends RegionLookupFactoryBean<K, V> imple
 
 	/**
 	 * Sets the region attributes used for the region used by this factory.
-	 * Allows maximum control in specifying the region settings.
-	 * Used only when a new region is created.
+	 * Allows maximum control in specifying the region settings. Used only when
+	 * a new region is created.
 	 * 
 	 * @param attributes the attributes to set on a newly created region
 	 */
diff --git a/src/main/java/org/springframework/data/gemfire/config/AbstractRegionParser.java b/src/main/java/org/springframework/data/gemfire/config/AbstractRegionParser.java
index 55930f14..877edc85 100644
--- a/src/main/java/org/springframework/data/gemfire/config/AbstractRegionParser.java
+++ b/src/main/java/org/springframework/data/gemfire/config/AbstractRegionParser.java
@@ -22,8 +22,6 @@ import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.beans.factory.config.BeanDefinitionHolder;
 import org.springframework.beans.factory.support.BeanDefinitionBuilder;
 import org.springframework.beans.factory.xml.ParserContext;
-import org.springframework.data.gemfire.RegionFactoryBean;
-import org.springframework.data.gemfire.SubRegionFactoryBean;
 import org.springframework.util.StringUtils;
 import org.w3c.dom.Element;
 
@@ -34,35 +32,26 @@ import org.w3c.dom.Element;
  */
 abstract class AbstractRegionParser extends AliasReplacingBeanDefinitionParser {
 	protected final Log log = LogFactory.getLog(getClass());
-	
-	protected Class<?> getBeanClass(Element element) {
-		if (element.hasAttribute("subregion")) {
-			return SubRegionFactoryBean.class;
-		}
-		else {
-			return RegionFactoryBean.class;
-		}
-	}
 
 	@Override
-	protected void doParseInternal(Element element, ParserContext parserContext, BeanDefinitionBuilder builder){
+	protected void doParseInternal(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
 		super.doParse(element, builder);
-		boolean subRegion = element.hasAttribute("subregion");
-		
+		boolean subRegion = isSubRegion(element);
+
 		doParseRegion(element, parserContext, builder, subRegion);
-		
+
 		if (subRegion) {
-			builder.addPropertyValue("parent", parserContext.getContainingBeanDefinition().getAttribute("parent")); 
+			builder.addPropertyValue("parent", parserContext.getContainingBeanDefinition().getAttribute("parent"));
 			builder.addPropertyValue("regionName", element.getAttribute(NAME_ATTRIBUTE));
 		}
 	}
-	
+
 	protected abstract void doParseRegion(Element element, ParserContext parserContext, BeanDefinitionBuilder builder,
 			boolean subRegion);
 
 	protected void doParseSubRegion(Element element, Element subElement, ParserContext parserContext,
 			BeanDefinitionBuilder builder, boolean subRegion) {
- 
+
 		String regionPath = null;
 		String parentBeanName = null;
 		if (subRegion) {
@@ -71,28 +60,26 @@ abstract class AbstractRegionParser extends AliasReplacingBeanDefinitionParser {
 		else {
 			parentBeanName = getRegionNameFromElement(element);
 		}
-		regionPath = StringUtils
-				.arrayToDelimitedString(
-						new String[] { parentBeanName, getRegionNameFromElement(subElement) }, "/");
+		regionPath = StringUtils.arrayToDelimitedString(new String[] { parentBeanName,
+				getRegionNameFromElement(subElement) }, "/");
 		if (!regionPath.startsWith("/")) {
 			regionPath = "/" + regionPath;
 		}
-
 		/*
-		 * The Region parser needs some context to handle recursion correctly 
+		 * The Region parser needs some context to handle recursion correctly
 		 */
 		builder.getBeanDefinition().setAttribute("parent",
 				new BeanDefinitionHolder(builder.getBeanDefinition(), parentBeanName));
-		builder.getBeanDefinition().setAttribute("regionPath",regionPath);
+		builder.getBeanDefinition().setAttribute("regionPath", regionPath);
 
 		// Make recursive call
 		BeanDefinition subRegionDef = this.parseSubRegion(subElement, parserContext, builder);
-		//TODO: Is there a better work-around?
+		// TODO: Is there a better work-around?
 		/*
 		 * This setting prevents the BF from generating a name for this been
 		 */
 		subRegionDef.setScope(BeanDefinition.SCOPE_PROTOTYPE);
-        
+
 		if (log.isDebugEnabled()) {
 			log.debug("registering subregion as " + regionPath);
 		}
@@ -100,17 +87,13 @@ abstract class AbstractRegionParser extends AliasReplacingBeanDefinitionParser {
 	}
 
 	private BeanDefinition parseSubRegion(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
-        /*
-         * Easy way to mark this element as a subregion
-         */
-		element.setAttribute("subregion", "true");
 		BeanDefinition beanDefinition = parserContext.getDelegate().parseCustomElement(element,
 				builder.getBeanDefinition());
 		return beanDefinition;
 	}
-	
-	private String getRegionNameFromElement(Element element){
+
+	private String getRegionNameFromElement(Element element) {
 		String name = element.getAttribute(NAME_ATTRIBUTE);
-		return StringUtils.hasText(name)? name: element.getAttribute(ID_ATTRIBUTE);
+		return StringUtils.hasText(name) ? name : element.getAttribute(ID_ATTRIBUTE);
 	}
 }
\ No newline at end of file
diff --git a/src/main/java/org/springframework/data/gemfire/config/AliasReplacingBeanDefinitionParser.java b/src/main/java/org/springframework/data/gemfire/config/AliasReplacingBeanDefinitionParser.java
index 2ef4259c..e8d2f951 100644
--- a/src/main/java/org/springframework/data/gemfire/config/AliasReplacingBeanDefinitionParser.java
+++ b/src/main/java/org/springframework/data/gemfire/config/AliasReplacingBeanDefinitionParser.java
@@ -26,36 +26,43 @@ import org.springframework.data.gemfire.SubRegionFactoryBean;
 import org.w3c.dom.Element;
 
 /**
- * Extension class dealing with the attribute clash (name) that triggers the region name to
- * be considered a bean alias. Overrides the automatic alias detection and replaces it with its own
- * using meta attributes (since the parsing method is final).
+ * Extension class dealing with the attribute clash (name) that triggers the
+ * region name to be considered a bean alias. Overrides the automatic alias
+ * detection and replaces it with its own using meta attributes (since the
+ * parsing method is final).
  * 
  * @author Costin Leau
  */
 abstract class AliasReplacingBeanDefinitionParser extends AbstractSingleBeanDefinitionParser {
 
+	@Override
 	protected Class<?> getBeanClass(Element element) {
-		if (element.hasAttribute("subregion")){
-			System.out.println("building subregion " + element.getAttribute(NAME_ATTRIBUTE));
+
+		if (isSubRegion(element)) {
 			return SubRegionFactoryBean.class;
-		} else {
+		}
+		else {
 			return RegionFactoryBean.class;
 		}
 	}
 
 	@Override
 	protected final void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
-		
+
 		ParsingUtils.addBeanAliasAsMetadata(element, builder);
-		
+
 		doParseInternal(element, parserContext, builder);
 	}
 
 	@Override
 	protected void registerBeanDefinition(BeanDefinitionHolder definition, BeanDefinitionRegistry registry) {
-		// add the aliases from the metadata 
+		// add the aliases from the metadata
 		super.registerBeanDefinition(ParsingUtils.replaceBeanAliasAsMetadata(definition), registry);
 	}
 
+	protected boolean isSubRegion(Element element) {
+		return element.getParentNode().getLocalName().endsWith("region");
+	}
+
 	protected abstract void doParseInternal(Element element, ParserContext parserContext, BeanDefinitionBuilder builder);
 }
\ No newline at end of file
diff --git a/src/main/java/org/springframework/data/gemfire/config/DiskStoreParser.java b/src/main/java/org/springframework/data/gemfire/config/DiskStoreParser.java
new file mode 100644
index 00000000..7444b28d
--- /dev/null
+++ b/src/main/java/org/springframework/data/gemfire/config/DiskStoreParser.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2010-2012 the original author or authors.
+ *
+ * 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.
+ */
+package org.springframework.data.gemfire.config;
+
+import java.util.List;
+
+import org.springframework.beans.factory.support.AbstractBeanDefinition;
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.support.ManagedList;
+import org.springframework.beans.factory.xml.AbstractSingleBeanDefinitionParser;
+import org.springframework.beans.factory.xml.ParserContext;
+import org.springframework.data.gemfire.DiskStoreFactoryBean;
+import org.springframework.data.gemfire.DiskStoreFactoryBean.DiskDir;
+import org.springframework.util.CollectionUtils;
+import org.springframework.util.xml.DomUtils;
+import org.w3c.dom.Element;
+
+/**
+ * @author David Turanski
+ * 
+ */
+public class DiskStoreParser extends AbstractSingleBeanDefinitionParser {
+	@Override
+	protected Class<?> getBeanClass(Element element) {
+		return DiskStoreFactoryBean.class;
+	}
+
+	@Override
+	protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
+		super.doParse(element, parserContext, builder);
+		ParsingUtils.setPropertyReference(element, builder, "cache-ref", "cache");
+		ParsingUtils.setPropertyValue(element, builder, "auto-compact");
+		ParsingUtils.setPropertyValue(element, builder, "allow-force-compaction");
+		ParsingUtils.setPropertyValue(element, builder, "max-oplog-size");
+		ParsingUtils.setPropertyValue(element, builder, "time-interval");
+		ParsingUtils.setPropertyValue(element, builder, "queue-size");
+		ParsingUtils.setPropertyValue(element, builder, "compaction-threshold");
+		ParsingUtils.setPropertyValue(element, builder, "write-buffer-size");
+
+		List<Element> diskDirElements = DomUtils.getChildElementsByTagName(element, "disk-dir");
+
+		if (!CollectionUtils.isEmpty(diskDirElements)) {
+			ManagedList<AbstractBeanDefinition> diskDirs = new ManagedList<AbstractBeanDefinition>();
+			for (Element diskDirElement : diskDirElements) {
+				BeanDefinitionBuilder diskDirBuilder = BeanDefinitionBuilder.genericBeanDefinition(DiskDir.class);
+				diskDirBuilder.addConstructorArgValue(diskDirElement.getAttribute("location"));
+				if (diskDirElement.hasAttribute("max-size")) {
+					diskDirBuilder.addConstructorArgValue(diskDirElement.getAttribute("max-size"));
+				}
+				diskDirs.add(diskDirBuilder.getBeanDefinition());
+			}
+			builder.addPropertyValue("diskDirs", diskDirs);
+		}
+	}
+}
diff --git a/src/main/java/org/springframework/data/gemfire/config/DiskWriteAttributesFactoryBean.java b/src/main/java/org/springframework/data/gemfire/config/DiskWriteAttributesFactoryBean.java
index 32ada080..493dc356 100644
--- a/src/main/java/org/springframework/data/gemfire/config/DiskWriteAttributesFactoryBean.java
+++ b/src/main/java/org/springframework/data/gemfire/config/DiskWriteAttributesFactoryBean.java
@@ -23,27 +23,35 @@ import com.gemstone.gemfire.cache.DiskWriteAttributes;
 import com.gemstone.gemfire.cache.DiskWriteAttributesFactory;
 
 /**
- * Simple utility class used for defining nested factory-method like definitions w/o polluting the container with useless beans.
+ * Simple utility class used for defining nested factory-method like definitions
+ * w/o polluting the container with useless beans.
  * 
  * @author Costin Leau
+ * @deprecated
  */
+@Deprecated
 class DiskWriteAttributesFactoryBean implements FactoryBean<DiskWriteAttributes>, InitializingBean {
 
 	private DiskWriteAttributes attributes;
+
 	private DiskWriteAttributesFactory attrFactory;
 
+	@Override
 	public void afterPropertiesSet() {
 		attributes = attrFactory.create();
 	}
 
+	@Override
 	public DiskWriteAttributes getObject() throws Exception {
 		return attributes;
 	}
 
+	@Override
 	public Class<?> getObjectType() {
 		return (attributes != null ? attributes.getClass() : DiskWriteAttributes.class);
 	}
 
+	@Override
 	public boolean isSingleton() {
 		return true;
 	}
diff --git a/src/main/java/org/springframework/data/gemfire/config/GemfireNamespaceHandler.java b/src/main/java/org/springframework/data/gemfire/config/GemfireNamespaceHandler.java
index 68f52bfa..ca69e83a 100644
--- a/src/main/java/org/springframework/data/gemfire/config/GemfireNamespaceHandler.java
+++ b/src/main/java/org/springframework/data/gemfire/config/GemfireNamespaceHandler.java
@@ -23,9 +23,11 @@ import org.springframework.data.gemfire.repository.config.GemfireRepositoryParse
  * Namespace handler for GemFire definitions.
  * 
  * @author Costin Leau
+ * @author David Turanski
  */
 class GemfireNamespaceHandler extends NamespaceHandlerSupport {
 
+	@Override
 	public void init() {
 		registerBeanDefinitionParser("cache", new CacheParser());
 		registerBeanDefinitionParser("client-cache", new ClientCacheParser());
@@ -33,15 +35,14 @@ class GemfireNamespaceHandler extends NamespaceHandlerSupport {
 		registerBeanDefinitionParser("lookup-region", new LookupRegionParser());
 		registerBeanDefinitionParser("replicated-region", new ReplicatedRegionParser());
 		registerBeanDefinitionParser("partitioned-region", new PartitionedRegionParser());
+		registerBeanDefinitionParser("local-region", new LocalRegionParser());
 		registerBeanDefinitionParser("client-region", new ClientRegionParser());
 		registerBeanDefinitionParser("pool", new PoolParser());
 		registerBeanDefinitionParser("index", new IndexParser());
+		registerBeanDefinitionParser("disk-store", new DiskStoreParser());
 		registerBeanDefinitionParser("cache-server", new CacheServerParser());
-
 		registerBeanDefinitionParser("transaction-manager", new TransactionManagerParser());
-
 		registerBeanDefinitionParser("cq-listener-container", new GemfireListenerContainerParser());
-
 		registerBeanDefinitionParser("repositories", new GemfireRepositoryParser());
 	}
 }
\ No newline at end of file
diff --git a/src/main/java/org/springframework/data/gemfire/config/LocalRegionParser.java b/src/main/java/org/springframework/data/gemfire/config/LocalRegionParser.java
new file mode 100644
index 00000000..0111be65
--- /dev/null
+++ b/src/main/java/org/springframework/data/gemfire/config/LocalRegionParser.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright 2010-2012 the original author or authors.
+ *
+ * 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.
+ */
+
+package org.springframework.data.gemfire.config;
+
+import java.util.List;
+
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.xml.ParserContext;
+import org.springframework.data.gemfire.RegionAttributesFactoryBean;
+import org.springframework.util.StringUtils;
+import org.springframework.util.xml.DomUtils;
+import org.w3c.dom.Element;
+
+import com.gemstone.gemfire.cache.Scope;
+
+/**
+ * Parser for &lt;replicated-region;gt; definitions.
+ * 
+ * @author Costin Leau
+ * @author David Turanski
+ */
+class LocalRegionParser extends AbstractRegionParser {
+	@Override
+	protected void doParseRegion(Element element, ParserContext parserContext, BeanDefinitionBuilder builder,
+			boolean subRegion) {
+
+		// set the data policy
+		String attr = element.getAttribute("persistent");
+		// if (Boolean.parseBoolean(attr)) {
+		// builder.addPropertyValue("dataPolicy",
+		// DataPolicy.PERSISTENT_REPLICATE);
+		// }
+		// else {
+		// builder.addPropertyValue("dataPolicy", DataPolicy.REPLICATE);
+		// }
+
+		builder.addPropertyValue("scope", Scope.LOCAL);
+
+		ParsingUtils.setPropertyValue(element, builder, "name", "name");
+
+		BeanDefinitionBuilder attrBuilder = builder;
+
+		if (!subRegion) {
+			attr = element.getAttribute("cache-ref");
+			// add cache reference (fallback to default if nothing is specified)
+			builder.addPropertyReference("cache", (StringUtils.hasText(attr) ? attr : "gemfire-cache"));
+			attrBuilder = BeanDefinitionBuilder.genericBeanDefinition(RegionAttributesFactoryBean.class);
+		}
+		// add attributes
+
+		ParsingUtils.parseStatistics(element, attrBuilder);
+
+		attr = element.getAttribute("publisher");
+		if (StringUtils.hasText(attr)) {
+			attrBuilder.addPropertyValue("publisher", Boolean.valueOf(attr));
+		}
+
+		ParsingUtils.parseExpiration(parserContext, element, attrBuilder);
+		ParsingUtils.parseEviction(parserContext, element, attrBuilder);
+		ParsingUtils.parseDiskStorage(element, attrBuilder);
+
+		if (!subRegion) {
+			builder.addPropertyValue("attributes", attrBuilder.getBeanDefinition());
+		}
+
+		List<Element> subElements = DomUtils.getChildElements(element);
+
+		// parse nested elements
+		for (Element subElement : subElements) {
+			String name = subElement.getLocalName();
+
+			if ("cache-listener".equals(name)) {
+				builder.addPropertyValue("cacheListeners", parseCacheListener(parserContext, subElement, builder));
+			}
+
+			else if ("cache-loader".equals(name)) {
+				builder.addPropertyValue("cacheLoader", parseCacheLoader(parserContext, subElement, builder));
+			}
+
+			else if ("cache-writer".equals(name)) {
+				builder.addPropertyValue("cacheWriter", parseCacheWriter(parserContext, subElement, builder));
+			}
+			// subregion
+			else if (name.endsWith("region")) {
+				doParseSubRegion(element, subElement, parserContext, builder, subRegion);
+			}
+		}
+	}
+
+	private Object parseCacheListener(ParserContext parserContext, Element subElement, BeanDefinitionBuilder builder) {
+		return ParsingUtils.parseRefOrNestedBeanDeclaration(parserContext, subElement, builder);
+	}
+
+	private Object parseCacheLoader(ParserContext parserContext, Element subElement, BeanDefinitionBuilder builder) {
+		return ParsingUtils.parseRefOrNestedBeanDeclaration(parserContext, subElement, builder);
+	}
+
+	private Object parseCacheWriter(ParserContext parserContext, Element subElement, BeanDefinitionBuilder builder) {
+		return ParsingUtils.parseRefOrNestedBeanDeclaration(parserContext, subElement, builder);
+	}
+
+}
\ No newline at end of file
diff --git a/src/main/java/org/springframework/data/gemfire/config/LookupRegionParser.java b/src/main/java/org/springframework/data/gemfire/config/LookupRegionParser.java
index 0c32d54b..00affd19 100644
--- a/src/main/java/org/springframework/data/gemfire/config/LookupRegionParser.java
+++ b/src/main/java/org/springframework/data/gemfire/config/LookupRegionParser.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2011 the original author or authors.
+ * Copyright 2010-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -30,12 +30,13 @@ import org.w3c.dom.Element;
  * Parser for &lt;lookup-region;gt; definitions.
  * 
  * @author Costin Leau
+ * @author David Turanski
  */
 class LookupRegionParser extends AbstractRegionParser {
 
 	@Override
 	protected Class<?> getBeanClass(Element element) {
-		if (element.hasAttribute("subregion")) {
+		if (isSubRegion(element)) {
 			return SubRegionFactoryBean.class;
 		}
 		else {
diff --git a/src/main/java/org/springframework/data/gemfire/config/ParsingUtils.java b/src/main/java/org/springframework/data/gemfire/config/ParsingUtils.java
index 14def796..ad809893 100644
--- a/src/main/java/org/springframework/data/gemfire/config/ParsingUtils.java
+++ b/src/main/java/org/springframework/data/gemfire/config/ParsingUtils.java
@@ -27,11 +27,13 @@ import org.springframework.beans.factory.support.ManagedList;
 import org.springframework.beans.factory.xml.AbstractBeanDefinitionParser;
 import org.springframework.beans.factory.xml.BeanDefinitionParserDelegate;
 import org.springframework.beans.factory.xml.ParserContext;
+import org.springframework.core.Conventions;
+import org.springframework.data.gemfire.DiskStoreFactoryBean;
 import org.springframework.util.StringUtils;
 import org.springframework.util.xml.DomUtils;
 import org.w3c.dom.Element;
 
-import com.gemstone.gemfire.cache.DiskWriteAttributesFactory;
+import com.gemstone.gemfire.cache.DiskStoreFactory;
 import com.gemstone.gemfire.cache.ExpirationAction;
 import com.gemstone.gemfire.cache.ExpirationAttributes;
 
@@ -44,14 +46,20 @@ abstract class ParsingUtils {
 
 	private static final String ALIASES_KEY = ParsingUtils.class.getName() + ":aliases";
 
-	static void setPropertyValue(Element element, BeanDefinitionBuilder builder, String attrName, String propertyName) {
-		String attr = element.getAttribute(attrName);
+	static void setPropertyValue(Element element, BeanDefinitionBuilder builder, String attributeName,
+			String propertyName) {
+		String attr = element.getAttribute(attributeName);
 		if (StringUtils.hasText(attr)) {
 			builder.addPropertyValue(propertyName, attr);
 		}
 	}
 
-	static void setPropertyReference(Element element, BeanDefinitionBuilder builder, String attrName, String propertyName) {
+	static void setPropertyValue(Element element, BeanDefinitionBuilder builder, String attributeName) {
+		setPropertyValue(element, builder, attributeName, Conventions.attributeNameToPropertyName(attributeName));
+	}
+
+	static void setPropertyReference(Element element, BeanDefinitionBuilder builder, String attrName,
+			String propertyName) {
 		String attr = element.getAttribute(attrName);
 		if (StringUtils.hasText(attr)) {
 			builder.addPropertyReference(propertyName, attr);
@@ -59,9 +67,11 @@ abstract class ParsingUtils {
 	}
 
 	/**
-	 * Utility for parsing bean aliases. Normally parsed by AbstractBeanDefinitionParser however due to the attribute clash
-	 * (bean uses 'name' for aliases while region use it to indicate their name), the parser needs to handle this differently by
-	 * storing them as metadata which gets deleted just before registration.
+	 * Utility for parsing bean aliases. Normally parsed by
+	 * AbstractBeanDefinitionParser however due to the attribute clash (bean
+	 * uses 'name' for aliases while region use it to indicate their name), the
+	 * parser needs to handle this differently by storing them as metadata which
+	 * gets deleted just before registration.
 	 * 
 	 * @param element
 	 * @param builder
@@ -87,10 +97,13 @@ abstract class ParsingUtils {
 
 	/**
 	 * Utility method handling parsing of nested definition of the type:
+	 * 
 	 * <pre>
 	 *   <tag ref="someBean"/>
 	 * </pre>
-	 * or 
+	 * 
+	 * or
+	 * 
 	 * <pre>
 	 *   <tag>
 	 *     <bean .... />
@@ -100,11 +113,13 @@ abstract class ParsingUtils {
 	 * @param element
 	 * @return
 	 */
-	static Object parseRefOrNestedBeanDeclaration(ParserContext parserContext, Element element, BeanDefinitionBuilder builder) {
+	static Object parseRefOrNestedBeanDeclaration(ParserContext parserContext, Element element,
+			BeanDefinitionBuilder builder) {
 		return parseRefOrNestedBeanDeclaration(parserContext, element, builder, "ref");
 	}
 
-	static Object parseRefOrNestedBeanDeclaration(ParserContext parserContext, Element element, BeanDefinitionBuilder builder, String refAttrName) {
+	static Object parseRefOrNestedBeanDeclaration(ParserContext parserContext, Element element,
+			BeanDefinitionBuilder builder, String refAttrName) {
 		String attr = element.getAttribute(refAttrName);
 		boolean hasRef = StringUtils.hasText(attr);
 
@@ -142,10 +157,12 @@ abstract class ParsingUtils {
 	}
 
 	/**
-	 * Parses disk store sub-element. Populates the given attribute factory with the proper attributes.
+	 * Parses disk store sub-element. Populates the given attribute factory with
+	 * the proper attributes.
 	 * 
 	 * @param element - element enclosing the disk-store definition
-	 * @param beanBuilder - beanbuilder for a RegionAttributesFactoryBean instance
+	 * @param beanBuilder - beanbuilder for a RegionAttributesFactoryBean
+	 * instance
 	 * @return true if parsing actually occured, false otherwise
 	 */
 	static boolean parseDiskStorage(Element element, BeanDefinitionBuilder beanBuilder) {
@@ -154,14 +171,16 @@ abstract class ParsingUtils {
 		if (diskStoreElement == null)
 			return false;
 
-		BeanDefinitionBuilder diskDefBuilder = BeanDefinitionBuilder.genericBeanDefinition(DiskWriteAttributesFactory.class);
-		setPropertyValue(diskStoreElement, diskDefBuilder, "synchronous-write", "synchronous");
+		if (diskStoreElement.getParentNode().getLocalName().endsWith("region")) {
+			System.out.println("This is a nested disk-store");
+		}
+
+		BeanDefinitionBuilder diskDefBuilder = BeanDefinitionBuilder.genericBeanDefinition(DiskStoreFactory.class);
 		setPropertyValue(diskStoreElement, diskDefBuilder, "auto-compact", "rollOplogs");
 		setPropertyValue(diskStoreElement, diskDefBuilder, "max-oplog-size", "maxOplogSize");
 		setPropertyValue(diskStoreElement, diskDefBuilder, "time-interval", "timeInterval");
 		setPropertyValue(diskStoreElement, diskDefBuilder, "queue-size", "bytesThreshold");
 
-
 		// parse nested disk-dir
 		List<Element> list = DomUtils.getChildElementsByTagName(diskStoreElement, "disk-dir");
 		ManagedList<Object> locations = new ManagedList<Object>(list.size());
@@ -176,7 +195,7 @@ abstract class ParsingUtils {
 
 		// wrap up the disk attributes factory to call 'create'
 
-		BeanDefinitionBuilder factoryWrapper = BeanDefinitionBuilder.genericBeanDefinition(DiskWriteAttributesFactoryBean.class);
+		BeanDefinitionBuilder factoryWrapper = BeanDefinitionBuilder.genericBeanDefinition(DiskStoreFactoryBean.class);
 		factoryWrapper.addPropertyValue("diskAttributesFactory", diskDefBuilder.getBeanDefinition());
 		beanBuilder.addPropertyValue("diskWriteAttributes", factoryWrapper.getBeanDefinition());
 		beanBuilder.addPropertyValue("diskDirs", locations);
@@ -186,7 +205,8 @@ abstract class ParsingUtils {
 	}
 
 	/**
-	 * Parses the eviction sub-element. Populates the given attribute factory with the proper attributes.
+	 * Parses the eviction sub-element. Populates the given attribute factory
+	 * with the proper attributes.
 	 * 
 	 * @param parserContext
 	 * @param element
@@ -199,7 +219,8 @@ abstract class ParsingUtils {
 		if (evictionElement == null)
 			return false;
 
-		BeanDefinitionBuilder evictionDefBuilder = BeanDefinitionBuilder.genericBeanDefinition(EvictionAttributesFactoryBean.class);
+		BeanDefinitionBuilder evictionDefBuilder = BeanDefinitionBuilder
+				.genericBeanDefinition(EvictionAttributesFactoryBean.class);
 
 		// do manual conversion since the enum is not public
 		String attr = evictionElement.getAttribute("type");
@@ -210,7 +231,6 @@ abstract class ParsingUtils {
 		setPropertyValue(evictionElement, evictionDefBuilder, "threshold", "threshold");
 		setPropertyValue(evictionElement, evictionDefBuilder, "action", "action");
 
-
 		// get object sizer (if declared)
 		Element objectSizerElement = DomUtils.getChildElementByTagName(evictionElement, "object-sizer");
 
@@ -223,13 +243,13 @@ abstract class ParsingUtils {
 		return true;
 	}
 
-
 	static void parseStatistics(Element element, BeanDefinitionBuilder attrBuilder) {
 		setPropertyValue(element, attrBuilder, "statistics", "statisticsEnabled");
 	}
 
 	/**
-	 * Parses the expiration sub-elements. Populates the given attribute factory with proper attributes. 
+	 * Parses the expiration sub-elements. Populates the given attribute factory
+	 * with proper attributes.
 	 * 
 	 * @param parserContext
 	 * @param element
@@ -250,7 +270,25 @@ abstract class ParsingUtils {
 		return result;
 	}
 
-	private static boolean parseExpiration(Element rootElement, String elementName, String propertyName, BeanDefinitionBuilder attrBuilder) {
+	static void parseAdditionalAttributes(ParserContext parserContext, Element element,
+			BeanDefinitionBuilder attrBuilder) {
+		setPropertyValue(element, attrBuilder, "persistent", "persistBackup");
+		setPropertyValue(element, attrBuilder, "ignore-jta", "ignoreJTA");
+		setPropertyValue(element, attrBuilder, "key-constraint", "keyConstraint");
+		setPropertyValue(element, attrBuilder, "value-constraint", "valueConstraint");
+		setPropertyValue(element, attrBuilder, "lock-grantor", "lockGrantor");
+		setPropertyValue(element, attrBuilder, "enable-subscription-conflation", "enableSubscriptionConflation");
+		setPropertyValue(element, attrBuilder, "enable-async-conflation", "enableAsyncConflation");
+		setPropertyValue(element, attrBuilder, "initial-capacity", "initialCapacity");
+		String indexUpdateType = element.getAttribute("index-update-type");
+		if (StringUtils.hasText(indexUpdateType)) {
+			attrBuilder.addPropertyValue("indexMaintenanceSynchronous", "synchronous".equals(indexUpdateType));
+		}
+
+	}
+
+	private static boolean parseExpiration(Element rootElement, String elementName, String propertyName,
+			BeanDefinitionBuilder attrBuilder) {
 		Element expirationElement = DomUtils.getChildElementByTagName(rootElement, elementName);
 
 		if (expirationElement == null)
@@ -259,7 +297,6 @@ abstract class ParsingUtils {
 		String expirationTime = null;
 		ExpirationAction action = ExpirationAction.INVALIDATE;
 
-
 		// do manual conversion since the enum is not public
 		String attr = expirationElement.getAttribute("timeout");
 		if (StringUtils.hasText(attr)) {
@@ -284,7 +321,8 @@ abstract class ParsingUtils {
 				action = ExpirationAction.LOCAL_INVALIDATE;
 			}
 		}
-		BeanDefinitionBuilder expirationAttributes = BeanDefinitionBuilder.genericBeanDefinition(ExpirationAttributes.class);
+		BeanDefinitionBuilder expirationAttributes = BeanDefinitionBuilder
+				.genericBeanDefinition(ExpirationAttributes.class);
 		expirationAttributes.addConstructorArgValue(expirationTime);
 		expirationAttributes.addConstructorArgValue(action);
 		attrBuilder.addPropertyValue(propertyName, expirationAttributes.getBeanDefinition());
diff --git a/src/main/java/org/springframework/data/gemfire/config/PartitionedRegionParser.java b/src/main/java/org/springframework/data/gemfire/config/PartitionedRegionParser.java
index aec50710..78e504c3 100644
--- a/src/main/java/org/springframework/data/gemfire/config/PartitionedRegionParser.java
+++ b/src/main/java/org/springframework/data/gemfire/config/PartitionedRegionParser.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2011 the original author or authors.
+ * Copyright 2010-2012 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/springframework/data/gemfire/config/ReplicatedRegionParser.java b/src/main/java/org/springframework/data/gemfire/config/ReplicatedRegionParser.java
index 830f85ea..bb40f29a 100644
--- a/src/main/java/org/springframework/data/gemfire/config/ReplicatedRegionParser.java
+++ b/src/main/java/org/springframework/data/gemfire/config/ReplicatedRegionParser.java
@@ -61,7 +61,7 @@ class ReplicatedRegionParser extends AbstractRegionParser {
 			attrBuilder = BeanDefinitionBuilder.genericBeanDefinition(RegionAttributesFactoryBean.class);
 		}
 		// add attributes
-
+		ParsingUtils.parseAdditionalAttributes(parserContext, element, attrBuilder);
 		ParsingUtils.parseStatistics(element, attrBuilder);
 
 		attr = element.getAttribute("publisher");
diff --git a/src/main/resources/org/springframework/data/gemfire/config/spring-gemfire-1.2.xsd b/src/main/resources/org/springframework/data/gemfire/config/spring-gemfire-1.2.xsd
index 1a2fe21d..0f351362 100644
--- a/src/main/resources/org/springframework/data/gemfire/config/spring-gemfire-1.2.xsd
+++ b/src/main/resources/org/springframework/data/gemfire/config/spring-gemfire-1.2.xsd
@@ -1,90 +1,76 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<xsd:schema xmlns="http://www.springframework.org/schema/gemfire"
-    xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:beans="http://www.springframework.org/schema/beans"
-    xmlns:tool="http://www.springframework.org/schema/tool"
-    xmlns:repository="http://www.springframework.org/schema/data/repository"
-    targetNamespace="http://www.springframework.org/schema/gemfire"
-    elementFormDefault="qualified" attributeFormDefault="unqualified"
-    version="1.2">
-    <xsd:import namespace="http://www.springframework.org/schema/beans" />
-    <xsd:import namespace="http://www.springframework.org/schema/tool" />
-    <xsd:import namespace="http://www.springframework.org/schema/data/repository"
-        schemaLocation="http://www.springframework.org/schema/data/repository/spring-repository.xsd" />
-    <!-- -->
-    <xsd:annotation>
-        <xsd:documentation><![CDATA[
+<!-- edited with XMLSpy v2011 rel. 2 sp1 (http://www.altova.com) by David Turanski (EMC) -->
+<xsd:schema xmlns="http://www.springframework.org/schema/gemfire" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:beans="http://www.springframework.org/schema/beans" xmlns:tool="http://www.springframework.org/schema/tool" xmlns:repository="http://www.springframework.org/schema/data/repository" targetNamespace="http://www.springframework.org/schema/gemfire" elementFormDefault="qualified" attributeFormDefault="unqualified" version="1.2">
+	<xsd:import namespace="http://www.springframework.org/schema/beans"/>
+	<xsd:import namespace="http://www.springframework.org/schema/tool"/>
+	<xsd:import namespace="http://www.springframework.org/schema/data/repository" schemaLocation="http://www.springframework.org/schema/data/repository/spring-repository.xsd"/>
+	<!-- -->
+	<xsd:annotation>
+		<xsd:documentation><![CDATA[
             Namespace support for the Spring GemFire project.
         ]]></xsd:documentation>
-    </xsd:annotation>
-    <!-- -->
-    <xsd:complexType name="cacheBaseType">
-        <xsd:attribute name="id" type="xsd:ID" use="optional">
-            <xsd:annotation>
-                <xsd:documentation><![CDATA[
+	</xsd:annotation>
+	<!-- -->
+	<xsd:complexType name="cacheBaseType">
+		<xsd:attribute name="id" type="xsd:ID" use="optional">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
 The name of the cache definition (by default "gemfire-cache").]]></xsd:documentation>
-            </xsd:annotation>
-        </xsd:attribute>
-        <xsd:attribute name="cache-xml-location" type="xsd:string"
-            use="optional">
-            <xsd:annotation>
-                <xsd:documentation
-                    source="org.springframework.core.io.Resource"><![CDATA[
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="cache-xml-location" type="xsd:string" use="optional">
+			<xsd:annotation>
+				<xsd:documentation source="org.springframework.core.io.Resource"><![CDATA[
 The location of the GemFire cache xml file, as a Spring resource location: a URL, a "classpath:" pseudo URL,
 or a relative file path.
 				]]></xsd:documentation>
-            </xsd:annotation>
-        </xsd:attribute>
-        <xsd:attribute name="properties-ref" type="xsd:string"
-            use="optional">
-            <xsd:annotation>
-                <xsd:documentation source="java.util.Properties"><![CDATA[
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="properties-ref" type="xsd:string" use="optional">
+			<xsd:annotation>
+				<xsd:documentation source="java.util.Properties"><![CDATA[
 The bean name of a Java Properties object that will be used for property substitution. For loading properties
 consider using a dedicated utility such as the <util:*/> namespace and its 'properties' element.
 				]]></xsd:documentation>
-            </xsd:annotation>
-        </xsd:attribute>
-        <xsd:attribute name="use-bean-factory-locator"
-            type="xsd:string" use="optional" default="true">
-            <xsd:annotation>
-                <xsd:documentation><![CDATA[
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="use-bean-factory-locator" type="xsd:string" use="optional" default="true">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
 Indicates whether a bean factory locator is enabled (default) for this cache definition or not. The locator stores
 the enclosing bean factory reference to allow auto-wiring of Spring beans into GemFire managed classes. Usually disabled
 when the same cache is used in multiple application context/bean factories inside the same VM.
 				]]></xsd:documentation>
-            </xsd:annotation>
-        </xsd:attribute>
-        <xsd:attribute name="pdx-serializer" type="xsd:string"
-            use="optional">
-            <xsd:annotation>
-                <xsd:documentation><![CDATA[
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="pdx-serializer" type="xsd:string" use="optional">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
 Sets the PDX serializer for the cache. If this serializer is set, it will be consulted to see if it can serialize any 
 domain classes which are added to the cache in portable data exchange format. 				
 				]]></xsd:documentation>
-            </xsd:annotation>
-        </xsd:attribute>
-        <xsd:attribute name="pdx-disk-store" type="xsd:string"
-            use="optional">
-            <xsd:annotation>
-                <xsd:documentation><![CDATA[
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="pdx-disk-store" type="xsd:string" use="optional">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
 Sets the name of the disk store to use for PDX meta data. When serializing objects in the PDX format, 
 the type definitions are persisted to disk. This setting controls which disk store is used for that persistence.
 If not set, the metadata will go in the default disk store. 
 				]]></xsd:documentation>
-            </xsd:annotation>
-        </xsd:attribute>
-        <xsd:attribute name="pdx-persistent" type="xsd:string"
-            use="optional">
-            <xsd:annotation>
-                <xsd:documentation><![CDATA[
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="pdx-persistent" type="xsd:string" use="optional">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
 Control whether the type metadata for PDX objects is persisted to disk. The default for this setting is true. 
 If you are using a WAN gateway, or persistent regions, you should leave this set to true.
 				]]></xsd:documentation>
-            </xsd:annotation>
-        </xsd:attribute>
-        <xsd:attribute name="pdx-read-serialized" type="xsd:string"
-            use="optional">
-            <xsd:annotation>
-                <xsd:documentation><![CDATA[
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="pdx-read-serialized" type="xsd:string" use="optional">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
 Sets the object preference to PdxInstance type. When a cached object that was serialized as a PDX is read from the cache 
 a PdxInstance will be returned instead of the actual domain class. The PdxInstance is an interface that provides run time
 access to the fields of a PDX without deserializing the entire PDX. The PdxInstance implementation is a light weight wrapper
@@ -94,12 +80,11 @@ access PdxInstance instead of Java object.
 Note that a PdxInstance is only returned if a serialized PDX is found in the cache. If the cache contains a deserialized PDX, 
 then a domain class instance is returned instead of a PdxInstance. 				
 				]]></xsd:documentation>
-            </xsd:annotation>
-        </xsd:attribute>
-        <xsd:attribute name="pdx-ignore-unread-fields"
-            type="xsd:string" use="optional">
-            <xsd:annotation>
-                <xsd:documentation><![CDATA[
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="pdx-ignore-unread-fields" type="xsd:string" use="optional">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
 Controls whether pdx ignores fields that were unread during deserialization. The default is to preserve unread fields be
 including their data during serialization. But if you configure the cache to ignore unread fields then their data will be 
 lost during serialization.
@@ -107,229 +92,204 @@ lost during serialization.
 You should only set this attribute to true if you know this member will only be reading cache data. In this use case you 
 do not need to pay the cost of preserving the unread fields since you will never be reserializing pdx data. 				
 				]]></xsd:documentation>
-            </xsd:annotation>
-        </xsd:attribute>
-    </xsd:complexType>
-    <!-- -->
-    <xsd:element name="cache">
-        <xsd:annotation>
-            <xsd:documentation
-                source="org.springframework.data.gemfire.CacheFactoryBean"><![CDATA[
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:complexType>
+	<!-- -->
+	<xsd:element name="cache">
+		<xsd:annotation>
+			<xsd:documentation source="org.springframework.data.gemfire.CacheFactoryBean"><![CDATA[
 Defines a GemFire Cache instance used for creating or retrieving 'regions'.
 			]]></xsd:documentation>
-            <xsd:appinfo>
-                <tool:annotation>
-                    <tool:exports type="com.gemstone.gemfire.cache.Cache" />
-                </tool:annotation>
-            </xsd:appinfo>
-        </xsd:annotation>
-        <xsd:complexType>
-            <xsd:complexContent>
-                <xsd:extension base="cacheBaseType">
-                    <xsd:sequence>
-                        <xsd:element name="jndi-bindings"
-                            minOccurs="0" maxOccurs="1">
-                            <xsd:complexType>
-                                <xsd:sequence>
-                                    <xsd:element name="jndi-binding"
-                                        type="jndiBindingType"
-                                        minOccurs="1" maxOccurs="unbounded" />
-                                </xsd:sequence>
-                            </xsd:complexType>
-                        </xsd:element>
-                    </xsd:sequence>
-                    <xsd:attribute name="copy-on-read"
-                        type="xsd:string" use="optional" default="false">
-                        <xsd:annotation>
-                            <xsd:documentation><![CDATA[
+			<xsd:appinfo>
+				<tool:annotation>
+					<tool:exports type="com.gemstone.gemfire.cache.Cache"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="cacheBaseType">
+					<xsd:sequence>
+						<xsd:element name="jndi-bindings" minOccurs="0" maxOccurs="1">
+							<xsd:complexType>
+								<xsd:sequence>
+									<xsd:element name="jndi-binding" type="jndiBindingType" minOccurs="1" maxOccurs="unbounded"/>
+								</xsd:sequence>
+							</xsd:complexType>
+						</xsd:element>
+					</xsd:sequence>
+					<xsd:attribute name="copy-on-read" type="xsd:string" use="optional" default="false">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
 Controls whether entry value retrieval methods return direct references to the entry value objects in the cache (false) 
 or copies of the objects (true).           
                 ]]></xsd:documentation>
-                        </xsd:annotation>
-                    </xsd:attribute>
-                    <xsd:attribute name="lock-timeout"
-                        type="xsd:string" use="optional" default="60">
-                        <xsd:annotation>
-                            <xsd:documentation><![CDATA[
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="lock-timeout" type="xsd:string" use="optional" default="60">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
 The timeout, in seconds, for implicit object lock requests. This setting affects automatic locking only,
  and does not apply to manual locking. If a lock request does not return before the specified timeout period,
   it is cancelled and returns with a failure.
                   ]]></xsd:documentation>
-                        </xsd:annotation>
-                    </xsd:attribute>
-                    <xsd:attribute name="lock-lease" type="xsd:string"
-                        use="optional" default="120">
-                        <xsd:annotation>
-                            <xsd:documentation><![CDATA[
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="lock-lease" type="xsd:string" use="optional" default="120">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
 The timeout, in seconds, for implicit and explicit object lock leases. This affects both automatic locking and manual locking.
 Once a lock is obtained, it can remain in force for the lock lease time period before being automatically cleared by the system
                 ]]></xsd:documentation>
-                        </xsd:annotation>
-                    </xsd:attribute>
-                    <xsd:attribute name="message-sync-interval"
-                        type="xsd:string" use="optional" default="1">
-                        <xsd:annotation>
-                            <xsd:documentation><![CDATA[
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="message-sync-interval" type="xsd:string" use="optional" default="1">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
 Used for client subscription queue synchronization when this member acts as a server to clients and server redundancy is used.
 Sets the frequency (in seconds) at which the primary server sends messages to its secondary servers to remove queued events
 that have already been processed by the clients.
                 ]]></xsd:documentation>
-                        </xsd:annotation>
-                    </xsd:attribute>
-                    <xsd:attribute name="search-timeout"
-                        type="xsd:string" use="optional" default="300">
-                        <xsd:annotation>
-                            <xsd:documentation><![CDATA[
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="search-timeout" type="xsd:string" use="optional" default="300">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
 How many seconds a netSearch operation can wait for data before timing out.
 You may want to change this based on your knowledge of the network load or other factors.
                 ]]></xsd:documentation>
-                        </xsd:annotation>
-                    </xsd:attribute>
-                </xsd:extension>
-            </xsd:complexContent>
-        </xsd:complexType>
-    </xsd:element>
-    <!-- -->
-    <xsd:element name="client-cache">
-        <xsd:annotation>
-            <xsd:documentation
-                source="org.springframework.data.gemfire.client.ClientCacheFactoryBean"><![CDATA[
+						</xsd:annotation>
+					</xsd:attribute>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<!-- -->
+	<xsd:element name="client-cache">
+		<xsd:annotation>
+			<xsd:documentation source="org.springframework.data.gemfire.client.ClientCacheFactoryBean"><![CDATA[
 Defines a GemFire Client Cache instance used for creating or retrieving 'regions'.
 			]]></xsd:documentation>
-            <xsd:appinfo>
-                <tool:annotation>
-                    <tool:exports
-                        type="com.gemstone.gemfire.cache.client.ClientCache" />
-                </tool:annotation>
-            </xsd:appinfo>
-        </xsd:annotation>
-        <xsd:complexType>
-            <xsd:complexContent>
-                <xsd:extension base="cacheBaseType">
-                    <xsd:attribute name="pool-name" type="xsd:string"
-                        use="optional">
-                        <xsd:annotation>
-                            <xsd:documentation><![CDATA[
+			<xsd:appinfo>
+				<tool:annotation>
+					<tool:exports type="com.gemstone.gemfire.cache.client.ClientCache"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="cacheBaseType">
+					<xsd:attribute name="pool-name" type="xsd:string" use="optional">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
 The name of the pool used by this client.
 							]]></xsd:documentation>
-                        </xsd:annotation>
-                    </xsd:attribute>
-                </xsd:extension>
-            </xsd:complexContent>
-        </xsd:complexType>
-    </xsd:element>
-    <!-- -->
-    <xsd:element name="transaction-manager">
-        <xsd:annotation>
-            <xsd:documentation
-                source="org.springframework.data.gemfire.GemfireTransactionManager"><![CDATA[
+						</xsd:annotation>
+					</xsd:attribute>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<!-- -->
+	<xsd:element name="transaction-manager">
+		<xsd:annotation>
+			<xsd:documentation source="org.springframework.data.gemfire.GemfireTransactionManager"><![CDATA[
 Defines a GemFire Transaction Manager instance for a single GemFire cache.
 			]]></xsd:documentation>
-        </xsd:annotation>
-        <xsd:complexType>
-            <xsd:attribute name="id" type="xsd:ID" use="optional">
-                <xsd:annotation>
-                    <xsd:documentation><![CDATA[
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:attribute name="id" type="xsd:ID" use="optional">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
 The name of the transaction manager definition (by default "gemfire-transaction-manager").]]></xsd:documentation>
-                </xsd:annotation>
-            </xsd:attribute>
-            <xsd:attribute name="cache-ref" type="xsd:string"
-                use="optional" default="gemfire-cache">
-                <xsd:annotation>
-                    <xsd:documentation><![CDATA[
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="cache-ref" type="xsd:string" use="optional" default="gemfire-cache">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
 The name of the bean defining the GemFire cache (by default 'gemfire-cache').
 					]]></xsd:documentation>
-                </xsd:annotation>
-            </xsd:attribute>
-            <xsd:attribute name="copy-on-read" type="xsd:string"
-                use="optional" default="true">
-                <xsd:annotation>
-                    <xsd:documentation><![CDATA[
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="copy-on-read" type="xsd:string" use="optional" default="true">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
 Indicates whether the cache returns direct references or copies of the objects (default) it manages.
 While copies imply additional work for every fetch operation, direct references can cause dirty reads
 across concurrent threads in the same VM, whether or not transactions are used.
 					]]></xsd:documentation>
-                </xsd:annotation>
-            </xsd:attribute>
-        </xsd:complexType>
-    </xsd:element>
-    <!-- nested bean definition -->
-    <xsd:complexType name="beanDeclarationType">
-        <xsd:sequence>
-            <xsd:any namespace="##other" processContents="skip"
-                minOccurs="0" maxOccurs="1">
-                <xsd:annotation>
-                    <xsd:documentation><![CDATA[
+				</xsd:annotation>
+			</xsd:attribute>
+		</xsd:complexType>
+	</xsd:element>
+	<!-- nested bean definition -->
+	<xsd:complexType name="beanDeclarationType">
+		<xsd:sequence>
+			<xsd:any namespace="##other" processContents="skip" minOccurs="0" maxOccurs="1">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
 Inner bean definition. The nested declaration serves as an alternative to bean references (using 
 both in the same definition) is illegal.
 					]]></xsd:documentation>
-                </xsd:annotation>
-            </xsd:any>
-        </xsd:sequence>
-        <xsd:attribute name="ref" type="xsd:string" use="optional">
-            <xsd:annotation>
-                <xsd:documentation><![CDATA[
+				</xsd:annotation>
+			</xsd:any>
+		</xsd:sequence>
+		<xsd:attribute name="ref" type="xsd:string" use="optional">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
 The name of the bean referred by this declaration. If no reference exists, use an inner bean declaration.
 				]]></xsd:documentation>
-            </xsd:annotation>
-        </xsd:attribute>
-    </xsd:complexType>
-    <!-- -->
-    <xsd:complexType name="baseLookupRegionType">
-        <xsd:annotation>
-            <xsd:documentation><![CDATA[
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:complexType>
+	<!-- -->
+	<xsd:complexType name="baseLookupRegionType">
+		<xsd:annotation>
+			<xsd:documentation><![CDATA[
 Defines a lookup Subregion
                     ]]></xsd:documentation>
-            <xsd:appinfo>
-                <tool:annotation>
-                    <tool:exports type="com.gemstone.gemfire.cache.Region" />
-                </tool:annotation>
-            </xsd:appinfo>
-        </xsd:annotation>
-        <xsd:complexContent>
-            <xsd:extension base="basicRegionType">
-                <xsd:group ref="subRegionGroup"  minOccurs="0" maxOccurs="unbounded"/>
-            </xsd:extension>
-        </xsd:complexContent>
-    </xsd:complexType>
-    
-    <xsd:complexType name="basicSubRegionType">
-        <xsd:complexContent>
-            <xsd:extension base="baseLookupRegionType">
-                <xsd:attribute name="name" type="xsd:string">
-                        <xsd:annotation>
-                            <xsd:documentation><![CDATA[
+			<xsd:appinfo>
+				<tool:annotation>
+					<tool:exports type="com.gemstone.gemfire.cache.Region"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="basicRegionType">
+				<xsd:group ref="subRegionGroup" minOccurs="0" maxOccurs="unbounded"/>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="basicSubRegionType">
+		<xsd:complexContent>
+			<xsd:extension base="baseLookupRegionType">
+				<xsd:attribute name="name" type="xsd:string">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
 The name of the region definition.]]></xsd:documentation>
-                    </xsd:annotation>
-                </xsd:attribute>
-            </xsd:extension>
-        </xsd:complexContent>
-    </xsd:complexType>
-    
-    <xsd:complexType name="basicRegionType">
-        <xsd:annotation>
-            <xsd:appinfo>
-                <tool:annotation>
-                    <tool:exports type="com.gemstone.gemfire.cache.Region" />
-                </tool:annotation>
-            </xsd:appinfo>
-        </xsd:annotation>
-
-
-    </xsd:complexType>
-
-
-    <!-- -->
-    <xsd:complexType name="baseReadOnlyRegionType"
-        abstract="true">
-        <xsd:complexContent>
-            <xsd:extension base="basicRegionType">
-                <xsd:sequence>
-                    <xsd:element name="cache-listener"
-                        minOccurs="0" maxOccurs="1">
-                        <xsd:annotation>
-                            <xsd:documentation
-                                source="com.gemstone.gemfire.cache.CacheListener"><![CDATA[
+					</xsd:annotation>
+				</xsd:attribute>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="basicRegionType">
+		<xsd:annotation>
+			<xsd:appinfo>
+				<tool:annotation>
+					<tool:exports type="com.gemstone.gemfire.cache.Region"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+	</xsd:complexType>
+	<!-- -->
+	<xsd:complexType name="baseReadOnlyRegionType" abstract="true">
+		<xsd:complexContent>
+			<xsd:extension base="basicRegionType">
+				<xsd:sequence>
+					<xsd:element name="cache-listener" minOccurs="0" maxOccurs="1">
+						<xsd:annotation>
+							<xsd:documentation source="com.gemstone.gemfire.cache.CacheListener"><![CDATA[
 A cache listener definition for this region. A cache listener handles region or entry related events (that occur after
 various operations on the region). Multiple listeners can be declared in a nested manner.
 
@@ -337,64 +297,75 @@ Note: Avoid the risk of deadlock. Since the listener is invoked while holding a
 it is easy to generate a deadlock by interacting with the region. For this reason, it is highly recommended to use some
 other thread for accessing the region and not waiting for it to complete its task.
 							]]></xsd:documentation>
-                            <xsd:appinfo>
-                                <tool:annotation>
-                                    <tool:exports
-                                        type="com.gemstone.gemfire.cache.CacheListener" />
-                                </tool:annotation>
-                            </xsd:appinfo>
-                        </xsd:annotation>
-                        <xsd:complexType>
-                            <xsd:sequence>
-                                <xsd:any namespace="##other"
-                                    processContents="skip" minOccurs="0"
-                                    maxOccurs="unbounded">
-                                    <xsd:annotation>
-                                        <xsd:documentation><![CDATA[
+							<xsd:appinfo>
+								<tool:annotation>
+									<tool:exports type="com.gemstone.gemfire.cache.CacheListener"/>
+								</tool:annotation>
+							</xsd:appinfo>
+						</xsd:annotation>
+						<xsd:complexType>
+							<xsd:sequence>
+								<xsd:any namespace="##other" processContents="skip" minOccurs="0" maxOccurs="unbounded">
+									<xsd:annotation>
+										<xsd:documentation><![CDATA[
 Inner bean definition of the cache listener.
 										]]></xsd:documentation>
-                                    </xsd:annotation>
-                                </xsd:any>
-                            </xsd:sequence>
-                            <xsd:attribute name="ref"
-                                type="xsd:string" use="optional">
-                                <xsd:annotation>
-                                    <xsd:documentation><![CDATA[
+									</xsd:annotation>
+								</xsd:any>
+							</xsd:sequence>
+							<xsd:attribute name="ref" type="xsd:string" use="optional">
+								<xsd:annotation>
+									<xsd:documentation><![CDATA[
 The name of the cache listener bean referred by this declaration. Used as a convenience method. If no reference exists, 
 use inner bean declarations.
 									]]></xsd:documentation>
-                                </xsd:annotation>
-                            </xsd:attribute>
-                        </xsd:complexType>
-                    </xsd:element>
-                    <xsd:element name="disk-store" type="diskStoreType"
-                        minOccurs="0" maxOccurs="1">
-                        <xsd:annotation>
-                            <xsd:documentation><![CDATA[
+								</xsd:annotation>
+							</xsd:attribute>
+						</xsd:complexType>
+					</xsd:element>
+					<xsd:element name="disk-store" type="baseDiskStoreType" minOccurs="0" maxOccurs="1">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
 Disk storage configuration for the defined region.
 							]]></xsd:documentation>
-                        </xsd:annotation>
-                    </xsd:element>
-                </xsd:sequence>
-                <xsd:attribute name="persistent" type="xsd:string"
-                    default="false">
-                    <xsd:annotation>
-                        <xsd:documentation><![CDATA[
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+				<xsd:attribute name="persistent" type="xsd:string" default="false">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
 Indicates whether the defined region is persistent or not. GemFire ensures that all the data you put into a region that
  is configured for persistence will be written to disk in a way that it can be recovered the next time you create the 
 region. This allows data to be recovered after a machine or process failure or after an orderly shutdown and restart 
 of GemFire.
 
-Default is false, meaning the regions are not persisted.
+Default is false, meaning the regions are not persisted. 
 
 Note: Persistence for partitioned regions is supported only from GemFire 6.5 onwards.						
 						]]></xsd:documentation>
-                    </xsd:annotation>
-                </xsd:attribute>
-                <xsd:attribute name="destroy" type="xsd:string"
-                    default="false">
-                    <xsd:annotation>
-                        <xsd:documentation><![CDATA[
+					</xsd:annotation>
+				</xsd:attribute>
+				<xsd:attribute name="disk-synchronous" type="xsd:string" default="false">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+Indicates whether the writing to the disk si synchronous or not. Default is false, meaning asynchronous writing.
+
+Note this attribute only applies if a disk store is configured for this region.
+						]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:attribute>
+				<xsd:attribute name="disk-store-ref" type="xsd:string">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+Indicates the id of the disk store to use for persistence or overflow.
+
+Note this attribute only applies if a disk store is configured for this region.
+						]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:attribute>
+				<xsd:attribute name="destroy" type="xsd:string" default="false">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
 Indicates whether the defined region should be destroyed or not at shutdown. Destroy cascades to all entries and subregions.
 After the destroy, this region object can not be used any more and any attempt to use this region object will get 
 RegionDestroyedException.
@@ -403,12 +374,11 @@ Default is false, meaning that regions are not destroyed.
 
 Note: destroy and close are mutually exclusive. Enabling one will automatically disable the other.
 						]]></xsd:documentation>
-                    </xsd:annotation>
-                </xsd:attribute>
-                <xsd:attribute name="close" type="xsd:string"
-                    default="true">
-                    <xsd:annotation>
-                        <xsd:documentation><![CDATA[
+					</xsd:annotation>
+				</xsd:attribute>
+				<xsd:attribute name="close" type="xsd:string" default="true">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
 Indicates whether the defined region should be closed or not at shutdown. Close performs a local destroy but leaves behind the region
 disk files. Additionally it notifies the listeners and callbacks.
 
@@ -417,373 +387,467 @@ Default is true, meaning the regions are closed.
 Note: Regions are automatically closed when cache closes.
 Note: destroy and close are mutually exclusive. Enabling one will automatically disable the other.				
 						]]></xsd:documentation>
-                    </xsd:annotation>
-                </xsd:attribute>
-                <xsd:attribute name="statistics" type="xsd:string"
-                    default="false">
-                    <xsd:annotation>
-                        <xsd:documentation><![CDATA[
+					</xsd:annotation>
+				</xsd:attribute>
+				<xsd:attribute name="statistics" type="xsd:string" default="false">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
 Indicates whether statistics are enabled or disabled for this region and its entries.
 Default is false, meaning statistics are disabled.
 						]]></xsd:documentation>
-                    </xsd:annotation>
-                </xsd:attribute>
-            </xsd:extension>
-        </xsd:complexContent>
-    </xsd:complexType>
-    <!-- -->
-    <xsd:complexType name="readOnlyRegionType">
-        <xsd:complexContent>
-            <xsd:extension base="baseReadOnlyRegionType">
-                <xsd:attributeGroup ref="topLevelRegionAttributes" />
-            </xsd:extension>
-        </xsd:complexContent>
-    </xsd:complexType>
-    
-    <xsd:complexType name="readOnlySubRegionType">
-        <xsd:complexContent>
-            <xsd:extension base="baseReadOnlyRegionType">
-                <xsd:attribute name="name" type="xsd:string" use="required">
-                        <xsd:annotation>
-                            <xsd:documentation><![CDATA[
+					</xsd:annotation>
+				</xsd:attribute>
+				<xsd:attribute name="key-constraint" type="xsd:string" use="optional">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+The fully qualified class name of the expected key type
+								]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:attribute>
+				<xsd:attribute name="value-constraint" type="xsd:string" use="optional">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+The fully qualified class name of the expected value type
+								]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:attribute>
+				<xsd:attribute name="ignore-jta" type="xsd:string" use="optional" default="false">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+ Indicates whether operations on this region participates in active JTA transactions or ignores them and operates outside of transactions. This is primarily used in cache loaders, writers, and listeners that need to perform non-transactional operations on a region, such as caching a result set.
+								]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:attribute>
+				<xsd:attribute name="initial-capacity" type="xsd:string" use="optional" default="16">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+ Sets the initial capacity (number of entries) for the region
+								]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:attribute>
+				<xsd:attribute name="index-update-type" use="optional" default="synchronous">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+ Specifies whether region indexes are maintained synchronously with region modifications, or asynchronously in a background thread.
+								]]></xsd:documentation>
+					</xsd:annotation>
+					<xsd:simpleType>
+						<xsd:restriction base="xsd:string">
+							<xsd:enumeration value="asynchronous"/>
+							<xsd:enumeration value="synchronous"/>
+						</xsd:restriction>
+					</xsd:simpleType>
+				</xsd:attribute>
+				<xsd:attribute name="is-lock-grantor" type="xsd:string" use="optional" default="false">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+ Indicates whether 
+								]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:attribute>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!-- -->
+	<xsd:complexType name="readOnlyRegionType">
+		<xsd:complexContent>
+			<xsd:extension base="baseReadOnlyRegionType">
+				<xsd:attributeGroup ref="topLevelRegionAttributes"/>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!-- -->
+	<xsd:complexType name="readOnlySubRegionType">
+		<xsd:complexContent>
+			<xsd:extension base="baseReadOnlyRegionType">
+				<xsd:attribute name="name" type="xsd:string" use="required">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
 The name of the region definition.]]></xsd:documentation>
-                    </xsd:annotation>
-                </xsd:attribute>
-            </xsd:extension>
-        </xsd:complexContent>
-    </xsd:complexType>
-
-    <!-- -->
-    <xsd:complexType name="baseRegionType">
-        <xsd:complexContent>
-            <xsd:extension base="baseReadOnlyRegionType">
-                <xsd:sequence minOccurs="0" maxOccurs="1">
-                    <xsd:element name="cache-loader" type="beanDeclarationType"
-                        minOccurs="0" maxOccurs="1">
-                        <xsd:annotation>
-                            <xsd:documentation
-                                source="com.gemstone.gemfire.cache.CacheLoader"><![CDATA[
+					</xsd:annotation>
+				</xsd:attribute>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!-- -->
+	<xsd:complexType name="baseRegionType">
+		<xsd:complexContent>
+			<xsd:extension base="baseReadOnlyRegionType">
+				<xsd:sequence minOccurs="0" maxOccurs="1">
+					<xsd:element name="cache-loader" type="beanDeclarationType" minOccurs="0" maxOccurs="1">
+						<xsd:annotation>
+							<xsd:documentation source="com.gemstone.gemfire.cache.CacheLoader"><![CDATA[
 The cache loader definition for this region. A cache loader allows data to be placed into a region.
 							]]></xsd:documentation>
-                            <xsd:appinfo>
-                                <tool:annotation>
-                                    <tool:exports
-                                        type="com.gemstone.gemfire.cache.CacheLoader" />
-                                </tool:annotation>
-                            </xsd:appinfo>
-                        </xsd:annotation>
-                    </xsd:element>
-                    <xsd:element name="cache-writer" type="beanDeclarationType"
-                        minOccurs="0" maxOccurs="1">
-                        <xsd:annotation>
-                            <xsd:documentation
-                                source="com.gemstone.gemfire.cache.CacheWriter"><![CDATA[
+							<xsd:appinfo>
+								<tool:annotation>
+									<tool:exports type="com.gemstone.gemfire.cache.CacheLoader"/>
+								</tool:annotation>
+							</xsd:appinfo>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="cache-writer" type="beanDeclarationType" minOccurs="0" maxOccurs="1">
+						<xsd:annotation>
+							<xsd:documentation source="com.gemstone.gemfire.cache.CacheWriter"><![CDATA[
 The cache writer definition for this region. A cache writer acts as a dedicated synchronous listener that is notified
 before a region or an entry is modified. A typical example would be a writer that updates the database.
 
 Note: Only one CacheWriter is invoked. GemFire will always prefer the local one (if it exists) otherwise it will
 arbitrarily pick one.
 							]]></xsd:documentation>
-                            <xsd:appinfo>
-                                <tool:annotation>
-                                    <tool:exports
-                                        type="com.gemstone.gemfire.cache.CacheWriter" />
-                                </tool:annotation>
-                            </xsd:appinfo>
-                        </xsd:annotation>
-                    </xsd:element>
-                    <xsd:element name="region-ttl" type="expirationType"
-                        minOccurs="0" maxOccurs="1">
-                        <xsd:annotation>
-                            <xsd:documentation><![CDATA[[
+							<xsd:appinfo>
+								<tool:annotation>
+									<tool:exports type="com.gemstone.gemfire.cache.CacheWriter"/>
+								</tool:annotation>
+							</xsd:appinfo>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="region-ttl" type="expirationType" minOccurs="0" maxOccurs="1">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[[
 Time to live configuration for the region itself. Default: no expiration.
 							]]></xsd:documentation>
-                        </xsd:annotation>
-                    </xsd:element>
-                    <xsd:element name="region-tti" type="expirationType"
-                        minOccurs="0" maxOccurs="1">
-                        <xsd:annotation>
-                            <xsd:documentation><![CDATA[[
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="region-tti" type="expirationType" minOccurs="0" maxOccurs="1">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[[
 Time to idle (or idle timeout) configuration for the region itself. Default: no expiration.
 							]]></xsd:documentation>
-                        </xsd:annotation>
-                    </xsd:element>
-                    <xsd:element name="entry-ttl" type="expirationType"
-                        minOccurs="0" maxOccurs="1">
-                        <xsd:annotation>
-                            <xsd:documentation><![CDATA[[
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="entry-ttl" type="expirationType" minOccurs="0" maxOccurs="1">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[[
 Time to live configuration for the region entries. Default: no expiration.
 							]]></xsd:documentation>
-                        </xsd:annotation>
-                    </xsd:element>
-                    <xsd:element name="entry-tti" type="expirationType"
-                        minOccurs="0" maxOccurs="1">
-                        <xsd:annotation>
-                            <xsd:documentation><![CDATA[[
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="entry-tti" type="expirationType" minOccurs="0" maxOccurs="1">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[[
 Time to idle (or idle timeout) configuration for the region entries. Default: no expiration.
 							]]></xsd:documentation>
-                        </xsd:annotation>
-                    </xsd:element>
-                </xsd:sequence>
-            </xsd:extension>
-        </xsd:complexContent>
-    </xsd:complexType>
-    <!-- -->
-    <xsd:complexType name="regionType">
-        <xsd:complexContent>
-            <xsd:extension base="baseRegionType">
-                <xsd:attributeGroup ref="topLevelRegionAttributes" />
-            </xsd:extension>
-        </xsd:complexContent>
-    </xsd:complexType>
-    
-     <xsd:complexType name="subRegionType">
-        <xsd:complexContent>
-            <xsd:extension base="baseRegionType">
-               <xsd:attribute name="name" type="xsd:string" use="required">
-                    <xsd:annotation>
-                        <xsd:documentation><![CDATA[
+						</xsd:annotation>
+					</xsd:element>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!-- -->
+	<xsd:complexType name="regionType">
+		<xsd:complexContent>
+			<xsd:extension base="baseRegionType">
+				<xsd:attributeGroup ref="topLevelRegionAttributes"/>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="subRegionType">
+		<xsd:complexContent>
+			<xsd:extension base="baseRegionType">
+				<xsd:attribute name="name" type="xsd:string" use="required">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
                 The name of the region definition.
                         ]]></xsd:documentation>
-                    </xsd:annotation>
-                </xsd:attribute>
-            </xsd:extension>
-        </xsd:complexContent>
-    </xsd:complexType>
-    <!-- -->
-    <xsd:complexType name="lookupRegionType">
-        <xsd:complexContent>
-            <xsd:extension base="baseLookupRegionType">
-                <xsd:attributeGroup ref="topLevelRegionAttributes" />
-            </xsd:extension>
-        </xsd:complexContent>
-    </xsd:complexType>
-     <xsd:complexType name="lookupSubRegionType">
-        <xsd:complexContent>
-            <xsd:extension base="baseLookupRegionType">
-               <xsd:attribute name="name" type="xsd:string"  use="required">
-                    <xsd:annotation>
-                        <xsd:documentation><![CDATA[
+					</xsd:annotation>
+				</xsd:attribute>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!-- -->
+	<xsd:complexType name="lookupRegionType">
+		<xsd:complexContent>
+			<xsd:extension base="baseLookupRegionType">
+				<xsd:attributeGroup ref="topLevelRegionAttributes"/>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<xsd:complexType name="lookupSubRegionType">
+		<xsd:complexContent>
+			<xsd:extension base="baseLookupRegionType">
+				<xsd:attribute name="name" type="xsd:string" use="required">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
                 The name of the region definition.
                         ]]></xsd:documentation>
-                    </xsd:annotation>
-                </xsd:attribute>
-            </xsd:extension>
-        </xsd:complexContent>
-    </xsd:complexType>
-    <!-- -->
-    <xsd:group name="subRegionGroup">
-        <xsd:choice>
-            <xsd:element name="lookup-region" type="lookupSubRegionType" />
-            <xsd:element name="replicated-region" type="replicatedSubRegionType" />
-            <xsd:element name="partitioned-region" type="partitionedSubRegionType" />
-        </xsd:choice>
-    </xsd:group>
-    <!-- -->
-    <xsd:attributeGroup name="topLevelRegionAttributes">
-        <xsd:attribute name="id" type="xsd:ID" use="required">
-            <xsd:annotation>
-                <xsd:documentation><![CDATA[
+					</xsd:annotation>
+				</xsd:attribute>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!-- -->
+	<xsd:group name="subRegionGroup">
+		<xsd:choice>
+			<xsd:element name="lookup-region" type="lookupSubRegionType"/>
+			<xsd:element name="replicated-region" type="replicatedSubRegionType"/>
+			<xsd:element name="partitioned-region" type="partitionedSubRegionType"/>
+			<xsd:element name="local-region" type="localSubRegionType"/>
+		</xsd:choice>
+	</xsd:group>
+	<!-- -->
+	<xsd:attributeGroup name="topLevelRegionAttributes">
+		<xsd:attribute name="id" type="xsd:ID" use="required">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
 The id of the region bean definition.
 				]]></xsd:documentation>
-            </xsd:annotation>
-        </xsd:attribute>
-        <xsd:attribute name="cache-ref" type="xsd:string"
-            use="optional" default="gemfire-cache">
-            <xsd:annotation>
-                <xsd:documentation><![CDATA[
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="cache-ref" type="xsd:string" use="optional" default="gemfire-cache">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
 The name of the bean defining the GemFire cache (by default 'gemfire-cache').
 				]]></xsd:documentation>
-            </xsd:annotation>
-        </xsd:attribute>
-        <xsd:attribute name="name" type="xsd:string" use="optional">
-            <xsd:annotation>
-                <xsd:documentation><![CDATA[
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="name" type="xsd:string" use="optional">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
 The name of the region definition. If no specified, it will have the value of the id attribute (that is, the bean name). Required for subregions.
                 ]]></xsd:documentation>
-            </xsd:annotation>
-        </xsd:attribute>
-    </xsd:attributeGroup>
-    <!-- -->
-    <xsd:element name="lookup-region" type="lookupRegionType" />
-    <!-- -->
-    <xsd:complexType name="baseReplicatedRegionType">
-        <xsd:annotation>
-            <xsd:documentation
-                source="org.springframework.data.gemfire.RegionFactoryBean"><![CDATA[
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:attributeGroup>
+	<!-- -->
+	<xsd:element name="lookup-region" type="lookupRegionType"/>
+	<!-- -->
+	<xsd:complexType name="baseReplicatedRegionType">
+		<xsd:annotation>
+			<xsd:documentation source="org.springframework.data.gemfire.RegionFactoryBean"><![CDATA[
 Defines a GemFire replicated region instance. Each replicated region contains a complete copy of the data.
 As well as high availability, replication provides excellent performance as each region contains a complete,
 up to date copy of the data.
             ]]></xsd:documentation>
-            <xsd:appinfo>
-                <tool:annotation>
-                    <tool:exports type="com.gemstone.gemfire.cache.Region" />
-                </tool:annotation>
-            </xsd:appinfo>
-        </xsd:annotation>
-        <xsd:complexContent>
-            <xsd:extension base="baseRegionType">
-                <xsd:sequence minOccurs="1" maxOccurs="1">
-                    <xsd:element name="eviction" minOccurs="0"
-                        maxOccurs="1">
-                        <xsd:annotation>
-                            <xsd:documentation><![CDATA[
+			<xsd:appinfo>
+				<tool:annotation>
+					<tool:exports type="com.gemstone.gemfire.cache.Region"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="baseRegionType">
+				<xsd:sequence minOccurs="1" maxOccurs="1">
+					<xsd:element name="eviction" minOccurs="0" maxOccurs="1">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
 Eviction policy for the replicated region.
                                 ]]></xsd:documentation>
-                        </xsd:annotation>
-                        <xsd:complexType>
-                            <xsd:complexContent>
-                                <xsd:extension base="evictionType">
-                                    <xsd:attribute name="action"
-                                        type="evictionActionType" fixed="OVERFLOW_TO_DISK">
-                                        <xsd:annotation>
-                                            <xsd:documentation><![CDATA[
+						</xsd:annotation>
+						<xsd:complexType>
+							<xsd:complexContent>
+								<xsd:extension base="evictionType">
+									<xsd:attribute name="action" type="evictionActionType" fixed="OVERFLOW_TO_DISK">
+										<xsd:annotation>
+											<xsd:documentation><![CDATA[
 The action to take when performing eviction.
                                                 ]]></xsd:documentation>
-                                        </xsd:annotation>
-                                    </xsd:attribute>
-                                </xsd:extension>
-                            </xsd:complexContent>
-                        </xsd:complexType>
-                    </xsd:element>
-                    <xsd:group ref="subRegionGroup" minOccurs="0"
-                        maxOccurs="unbounded" />
-                </xsd:sequence>
-            </xsd:extension>
-        </xsd:complexContent>
-    </xsd:complexType>
-    <!-- -->
-    <xsd:complexType name="replicatedRegionType">
-        <xsd:complexContent>
-            <xsd:extension base="baseReplicatedRegionType">
-                <xsd:attributeGroup ref="topLevelRegionAttributes" />
-            </xsd:extension>
-        </xsd:complexContent>
-    </xsd:complexType>
-    
-      <xsd:complexType name="replicatedSubRegionType">
-        <xsd:complexContent>
-            <xsd:extension base="baseReplicatedRegionType">
-                   <xsd:attribute name="name" type="xsd:string" use="required">
-                    <xsd:annotation>
-                        <xsd:documentation><![CDATA[
+										</xsd:annotation>
+									</xsd:attribute>
+								</xsd:extension>
+							</xsd:complexContent>
+						</xsd:complexType>
+					</xsd:element>
+					<xsd:group ref="subRegionGroup" minOccurs="0" maxOccurs="unbounded"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!-- -->
+	<xsd:complexType name="replicatedRegionType">
+		<xsd:complexContent>
+			<xsd:extension base="baseReplicatedRegionType">
+				<xsd:attributeGroup ref="topLevelRegionAttributes"/>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!-- -->
+	<xsd:complexType name="replicatedSubRegionType">
+		<xsd:complexContent>
+			<xsd:extension base="baseReplicatedRegionType">
+				<xsd:attribute name="name" type="xsd:string" use="required">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
                 The name of the region definition.
                         ]]></xsd:documentation>
-                    </xsd:annotation>
-                </xsd:attribute>
-            </xsd:extension>
-        </xsd:complexContent>
-    </xsd:complexType>
-    
-
-    <!-- -->
-    <xsd:element name="replicated-region" type="replicatedRegionType" />
-    <!-- -->
-    <xsd:complexType name="basePartitionedRegionType">
-        <xsd:annotation>
-            <xsd:documentation
-                source="org.springframework.data.gemfire.RegionFactoryBean"><![CDATA[
+					</xsd:annotation>
+				</xsd:attribute>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!-- -->
+	<xsd:element name="replicated-region" type="replicatedRegionType"/>
+	<!-- -->
+	<xsd:complexType name="baseLocalRegionType">
+		<xsd:annotation>
+			<xsd:documentation source="org.springframework.data.gemfire.RegionFactoryBean"><![CDATA[
+Defines a GemFire local region instance. Each local region is scoped only to the local JVM.
+            ]]></xsd:documentation>
+			<xsd:appinfo>
+				<tool:annotation>
+					<tool:exports type="com.gemstone.gemfire.cache.Region"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="baseRegionType">
+				<xsd:sequence minOccurs="1" maxOccurs="1">
+					<xsd:element name="eviction" minOccurs="0" maxOccurs="1">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
+Eviction policy for the replicated region.
+                                ]]></xsd:documentation>
+						</xsd:annotation>
+						<xsd:complexType>
+							<xsd:complexContent>
+								<xsd:extension base="evictionType">
+									<xsd:attribute name="action" type="evictionActionType" fixed="OVERFLOW_TO_DISK">
+										<xsd:annotation>
+											<xsd:documentation><![CDATA[
+The action to take when performing eviction.
+                                                ]]></xsd:documentation>
+										</xsd:annotation>
+									</xsd:attribute>
+								</xsd:extension>
+							</xsd:complexContent>
+						</xsd:complexType>
+					</xsd:element>
+					<xsd:group ref="subRegionGroup" minOccurs="0" maxOccurs="unbounded"/>
+				</xsd:sequence>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!-- -->
+	<xsd:complexType name="localRegionType">
+		<xsd:complexContent>
+			<xsd:extension base="baseLocalRegionType">
+				<xsd:attributeGroup ref="topLevelRegionAttributes"/>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!-- -->
+	<xsd:complexType name="localSubRegionType">
+		<xsd:complexContent>
+			<xsd:extension base="baseLocalRegionType">
+				<xsd:attribute name="name" type="xsd:string" use="required">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+                The name of the region definition.
+                        ]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:attribute>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!-- -->
+	<xsd:element name="local-region" type="localRegionType"/>
+	<!-- -->
+	<xsd:complexType name="basePartitionedRegionType">
+		<xsd:annotation>
+			<xsd:documentation source="org.springframework.data.gemfire.RegionFactoryBean"><![CDATA[
 Defines a GemFire partitioned region instance. Through partitioning, the data is split across regions.
 Partitioning is useful when the amount of data to store is too large for one member to hold and work
 with as if it were a single entity. One can configure the partitioned region to store redundant copies
 in different members, for high availability in case of an application failure.
 			]]></xsd:documentation>
-            <xsd:appinfo>
-                <tool:annotation>
-                    <tool:exports type="com.gemstone.gemfire.cache.Region" />
-                </tool:annotation>
-            </xsd:appinfo>
-        </xsd:annotation>
-        <xsd:complexContent>
-            <xsd:extension base="baseRegionType">
-                <xsd:sequence>
-                    <xsd:element name="partition-resolver"
-                        type="beanDeclarationType" minOccurs="0"
-                        maxOccurs="1">
-                        <xsd:annotation>
-                            <xsd:documentation
-                                source="com.gemstone.gemfire.cache.PartitionResolver"><![CDATA[
+			<xsd:appinfo>
+				<tool:annotation>
+					<tool:exports type="com.gemstone.gemfire.cache.Region"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:complexContent>
+			<xsd:extension base="baseRegionType">
+				<xsd:sequence>
+					<xsd:element name="partition-resolver" type="beanDeclarationType" minOccurs="0" maxOccurs="1">
+						<xsd:annotation>
+							<xsd:documentation source="com.gemstone.gemfire.cache.PartitionResolver"><![CDATA[
 The partition resolver definition for this region, allowing for custom partitioning. GemFire uses the resolver to
 colocate data based on custom criterias (such as colocating trades by month and year).
 								]]></xsd:documentation>
-                            <xsd:appinfo>
-                                <tool:annotation>
-                                    <tool:exports
-                                        type="com.gemstone.gemfire.cache.PartitionResolver" />
-                                </tool:annotation>
-                            </xsd:appinfo>
-                        </xsd:annotation>
-                    </xsd:element>
-                    <xsd:element name="eviction" minOccurs="0"
-                        maxOccurs="1">
-                        <xsd:annotation>
-                            <xsd:documentation><![CDATA[
+							<xsd:appinfo>
+								<tool:annotation>
+									<tool:exports type="com.gemstone.gemfire.cache.PartitionResolver"/>
+								</tool:annotation>
+							</xsd:appinfo>
+						</xsd:annotation>
+					</xsd:element>
+					<xsd:element name="eviction" minOccurs="0" maxOccurs="1">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
 Eviction policy for the partitioned region.
 								]]></xsd:documentation>
-                        </xsd:annotation>
-                        <xsd:complexType>
-                            <xsd:complexContent>
-                                <xsd:extension base="evictionType">
-                                    <xsd:attribute name="action"
-                                        type="evictionActionType"
-                                        default="LOCAL_DESTROY">
-                                        <xsd:annotation>
-                                            <xsd:documentation><![CDATA[
+						</xsd:annotation>
+						<xsd:complexType>
+							<xsd:complexContent>
+								<xsd:extension base="evictionType">
+									<xsd:attribute name="action" type="evictionActionType" default="LOCAL_DESTROY">
+										<xsd:annotation>
+											<xsd:documentation><![CDATA[
 The action to take when performing eviction.
 												]]></xsd:documentation>
-                                        </xsd:annotation>
-                                    </xsd:attribute>
-                                </xsd:extension>
-                            </xsd:complexContent>
-                        </xsd:complexType>
-                    </xsd:element>
-                </xsd:sequence>
-                <xsd:attribute name="copies" use="optional"
-                    default="0">
-                    <xsd:annotation>
-                        <xsd:documentation><![CDATA[
+										</xsd:annotation>
+									</xsd:attribute>
+								</xsd:extension>
+							</xsd:complexContent>
+						</xsd:complexType>
+					</xsd:element>
+				</xsd:sequence>
+				<xsd:attribute name="scope" use="optional" default="distributed-ack">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+Determines how updates to region entries are distributed to the other caches in the distributed system where the region and entry are defined. Scope also determines whether to allow remote invocation of some of the region’s event handlers
+								]]></xsd:documentation>
+					</xsd:annotation>
+					<xsd:simpleType>
+						<xsd:restriction base="xsd:string">
+							<xsd:enumeration value="distributed-ack"/>
+							<xsd:enumeration value="distributed-no-ack"/>
+							<xsd:enumeration value="global"/>
+						</xsd:restriction>
+					</xsd:simpleType>
+				</xsd:attribute>
+				<xsd:attribute name="copies" use="optional" default="0">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
 The number of copies for each partition for high-availability. By default, no copies are created meaning there is no
 redundancy. Each copy provides extra backup at the expense of extra storages.
 						]]></xsd:documentation>
-                    </xsd:annotation>
-                    <xsd:simpleType>
-                        <xsd:restriction base="xsd:byte">
-                            <xsd:minInclusive value="0" />
-                            <xsd:maxInclusive value="3" />
-                        </xsd:restriction>
-                    </xsd:simpleType>
-                </xsd:attribute>
-                <xsd:attribute name="colocated-with" type="xsd:string"
-                    use="optional">
-                    <xsd:annotation>
-                        <xsd:documentation><![CDATA[
+					</xsd:annotation>
+					<xsd:simpleType>
+						<xsd:restriction base="xsd:byte">
+							<xsd:minInclusive value="0"/>
+							<xsd:maxInclusive value="3"/>
+						</xsd:restriction>
+					</xsd:simpleType>
+				</xsd:attribute>
+				<xsd:attribute name="colocated-with" type="xsd:string" use="optional">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
 The name of the partitioned region with which this newly created partitioned region is colocated.
 							]]></xsd:documentation>
-                    </xsd:annotation>
-                </xsd:attribute>
-                <xsd:attribute name="local-max-memory"
-                    type="xsd:string" use="optional">
-                    <xsd:annotation>
-                        <xsd:documentation><![CDATA[
+					</xsd:annotation>
+				</xsd:attribute>
+				<xsd:attribute name="local-max-memory" type="xsd:string" use="optional">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
 The maximum amount of memory, in megabytes, to be used by the region in this process. If not set, a default of 90%
 of available heap is used.
 							]]></xsd:documentation>
-                    </xsd:annotation>
-                </xsd:attribute>
-                <xsd:attribute name="total-max-memory"
-                    type="xsd:string" use="optional">
-                    <xsd:annotation>
-                        <xsd:documentation><![CDATA[
+					</xsd:annotation>
+				</xsd:attribute>
+				<xsd:attribute name="total-max-memory" type="xsd:string" use="optional">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
 The maximum amount of memory, in megabytes, to be used by the region in all process.
 
 Note: This setting must be the same in all processes using the region.
 							]]></xsd:documentation>
-                    </xsd:annotation>
-                </xsd:attribute>
-                <xsd:attribute name="total-buckets" type="xsd:string"
-                    use="optional">
-                    <xsd:annotation>
-                        <xsd:documentation><![CDATA[
+					</xsd:annotation>
+				</xsd:attribute>
+				<xsd:attribute name="total-buckets" type="xsd:string" use="optional">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
 The total number of hash buckets to be used by the region in all processes. 
 
 A bucket is the smallest unit of data management in a partitioned region. Entries are stored in buckets and buckets may
@@ -794,361 +858,367 @@ The number of buckets should be prime and as a rough guide at the least four tim
  
 Note: This setting must be the same in all processes using the region.
 							]]></xsd:documentation>
-                    </xsd:annotation>
-                </xsd:attribute>
-                <xsd:attribute name="recovery-delay" type="xsd:string"
-                    use="optional" default="-1">
-                    <xsd:annotation>
-                        <xsd:documentation><![CDATA[
+					</xsd:annotation>
+				</xsd:attribute>
+				<xsd:attribute name="recovery-delay" type="xsd:string" use="optional" default="-1">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
 The delay in milliseconds that existing members will wait before satisfying redundancy after another member crashes.
 -1 (the default) indicates that redundancy will not be recovered after a failure.
 							]]></xsd:documentation>
-                    </xsd:annotation>
-                </xsd:attribute>
-                <xsd:attribute name="startup-recovery-delay"
-                    type="xsd:string" use="optional" default="-1">
-                    <xsd:annotation>
-                        <xsd:documentation><![CDATA[
+					</xsd:annotation>
+				</xsd:attribute>
+				<xsd:attribute name="startup-recovery-delay" type="xsd:string" use="optional" default="-1">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
 The delay in milliseconds that new members will wait before satisfying redundancy. -1 indicates that adding new members
  will not trigger redundancy recovery. The default is to recover redundancy immediately when a new member is added.
  							]]></xsd:documentation>
-                    </xsd:annotation>
-                </xsd:attribute>
-            </xsd:extension>
-        </xsd:complexContent>
-    </xsd:complexType>
-    <!-- -->
-    <xsd:complexType name="partitionedRegionType">
-        <xsd:complexContent>
-            <xsd:extension base="basePartitionedRegionType">
-                <!-- subRegions not supported -->
-                <xsd:attributeGroup ref="topLevelRegionAttributes" />
-            </xsd:extension>
-        </xsd:complexContent>
-    </xsd:complexType>
-    
-      <xsd:complexType name="partitionedSubRegionType">
-        <xsd:complexContent>
-            <xsd:extension base="basePartitionedRegionType">
-                <!-- subRegions not supported -->
-                      <xsd:attribute name="name" type="xsd:string" use="required">
-                    <xsd:annotation>
-                        <xsd:documentation><![CDATA[
+					</xsd:annotation>
+				</xsd:attribute>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!-- -->
+	<xsd:complexType name="partitionedRegionType">
+		<xsd:complexContent>
+			<xsd:extension base="basePartitionedRegionType">
+				<xsd:attributeGroup ref="topLevelRegionAttributes"/>
+			</xsd:extension>
+			<!-- subRegions not supported -->
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!-- -->
+	<xsd:complexType name="partitionedSubRegionType">
+		<xsd:complexContent>
+			<xsd:extension base="basePartitionedRegionType">
+				<xsd:attribute name="name" type="xsd:string" use="required">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
                 The name of the region definition.
                         ]]></xsd:documentation>
-                    </xsd:annotation>
-                </xsd:attribute>
-            </xsd:extension>
-        </xsd:complexContent>
-    </xsd:complexType>
-
-    <!-- -->
-    <xsd:element name="partitioned-region" type="partitionedRegionType" />
-    <!-- -->
-    <xsd:complexType name="expirationType">
-        <xsd:attribute name="timeout" type="xsd:string"
-            default="0">
-            <xsd:annotation>
-                <xsd:documentation><![CDATA[
+					</xsd:annotation>
+				</xsd:attribute>
+			</xsd:extension>
+			<!-- subRegions not supported -->
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!-- -->
+	<xsd:element name="partitioned-region" type="partitionedRegionType"/>
+	<!-- -->
+	<xsd:complexType name="expirationType">
+		<xsd:attribute name="timeout" type="xsd:string" default="0">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
 The amount of time before the expiration action takes place. Defaults to zero (which means never timeout). 
 				]]></xsd:documentation>
-            </xsd:annotation>
-        </xsd:attribute>
-        <xsd:attribute name="action" default="INVALIDATE">
-            <xsd:simpleType>
-                <xsd:restriction base="xsd:string">
-                    <xsd:enumeration value="INVALIDATE">
-                        <xsd:annotation>
-                            <xsd:documentation><![CDATA[
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="action" default="INVALIDATE">
+			<xsd:simpleType>
+				<xsd:restriction base="xsd:string">
+					<xsd:enumeration value="INVALIDATE">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
 When the region or cached object expires, it is invalidated. 
 							]]></xsd:documentation>
-                        </xsd:annotation>
-                    </xsd:enumeration>
-                    <xsd:enumeration value="DESTROY">
-                        <xsd:annotation>
-                            <xsd:documentation><![CDATA[
+						</xsd:annotation>
+					</xsd:enumeration>
+					<xsd:enumeration value="DESTROY">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
 When the region or cached object expires, it is destroyed.
 							]]></xsd:documentation>
-                        </xsd:annotation>
-                    </xsd:enumeration>
-                    <xsd:enumeration value="LOCAL_INVALIDATE">
-                        <xsd:annotation>
-                            <xsd:documentation><![CDATA[
+						</xsd:annotation>
+					</xsd:enumeration>
+					<xsd:enumeration value="LOCAL_INVALIDATE">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
 When the region or cached object expires, it is invalidated locally only. Not supported on partitioned regions.
 							]]></xsd:documentation>
-                        </xsd:annotation>
-                    </xsd:enumeration>
-                    <xsd:enumeration value="LOCAL_DESTROY">
-                        <xsd:annotation>
-                            <xsd:documentation><![CDATA[
+						</xsd:annotation>
+					</xsd:enumeration>
+					<xsd:enumeration value="LOCAL_DESTROY">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
 When the region or cached object expires, it is destroyed locally only. Not supported on partitioned regions.
 							]]></xsd:documentation>
-                        </xsd:annotation>
-                    </xsd:enumeration>
-                </xsd:restriction>
-            </xsd:simpleType>
-        </xsd:attribute>
-    </xsd:complexType>
-    <!-- -->
-    <xsd:complexType name="evictionType">
-        <xsd:sequence minOccurs="0" maxOccurs="1">
-            <xsd:element name="object-sizer" type="beanDeclarationType">
-                <xsd:annotation>
-                    <xsd:documentation><![CDATA[
+						</xsd:annotation>
+					</xsd:enumeration>
+				</xsd:restriction>
+			</xsd:simpleType>
+		</xsd:attribute>
+	</xsd:complexType>
+	<!-- -->
+	<xsd:complexType name="evictionType">
+		<xsd:sequence minOccurs="0" maxOccurs="1">
+			<xsd:element name="object-sizer" type="beanDeclarationType">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
 Entity computing sizes for objects stored into the grid.
 					]]></xsd:documentation>
-                    <xsd:appinfo>
-                        <tool:annotation>
-                            <tool:exports
-                                type="com.gemstone.gemfire.cache.util.ObjectSizer" />
-                        </tool:annotation>
-                    </xsd:appinfo>
-                </xsd:annotation>
-            </xsd:element>
-        </xsd:sequence>
-        <xsd:attribute name="type" default="ENTRY_COUNT">
-            <xsd:simpleType>
-                <xsd:restriction base="xsd:string">
-                    <xsd:enumeration value="ENTRY_COUNT">
-                        <xsd:annotation>
-                            <xsd:documentation><![CDATA[
+					<xsd:appinfo>
+						<tool:annotation>
+							<tool:exports type="com.gemstone.gemfire.cache.util.ObjectSizer"/>
+						</tool:annotation>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+		<xsd:attribute name="type" default="ENTRY_COUNT">
+			<xsd:simpleType>
+				<xsd:restriction base="xsd:string">
+					<xsd:enumeration value="ENTRY_COUNT">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
 Considers the number of entries in the region before performing an eviction.
 							]]></xsd:documentation>
-                        </xsd:annotation>
-                    </xsd:enumeration>
-                    <xsd:enumeration value="MEMORY_SIZE">
-                        <xsd:annotation>
-                            <xsd:documentation><![CDATA[
+						</xsd:annotation>
+					</xsd:enumeration>
+					<xsd:enumeration value="MEMORY_SIZE">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
 Considers the amount of memory consumed by the region before performing an eviction.
 							]]></xsd:documentation>
-                        </xsd:annotation>
-                    </xsd:enumeration>
-                    <xsd:enumeration value="HEAP_PERCENTAGE">
-                        <xsd:annotation>
-                            <xsd:documentation><![CDATA[
+						</xsd:annotation>
+					</xsd:enumeration>
+					<xsd:enumeration value="HEAP_PERCENTAGE">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
 Considers the amount of heap used (through the GemFire resource manager) before performing an eviction.
 							]]></xsd:documentation>
-                        </xsd:annotation>
-                    </xsd:enumeration>
-                </xsd:restriction>
-            </xsd:simpleType>
-        </xsd:attribute>
-        <xsd:attribute name="threshold" type="xsd:string"
-            use="required">
-            <xsd:annotation>
-                <xsd:documentation><![CDATA[
+						</xsd:annotation>
+					</xsd:enumeration>
+				</xsd:restriction>
+			</xsd:simpleType>
+		</xsd:attribute>
+		<xsd:attribute name="threshold" type="xsd:string" use="required">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
 The threshold (or limit) against which the eviction algorithm runs. Once the threashold is reached, eviction is
 performed.
 				]]></xsd:documentation>
-            </xsd:annotation>
-        </xsd:attribute>
-    </xsd:complexType>
-    <!-- -->
-    <xsd:simpleType name="evictionActionType">
-        <xsd:restriction base="xsd:string">
-            <xsd:enumeration value="LOCAL_DESTROY">
-                <xsd:annotation>
-                    <xsd:documentation><![CDATA[
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:complexType>
+	<!-- -->
+	<xsd:simpleType name="evictionActionType">
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="LOCAL_DESTROY">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
 The LRU (least-recently-used) region entries is locally destroyed.
 
 Note: this option is not compatible with replicated regions (as it render the replica region incomplete).  
 							]]></xsd:documentation>
-                </xsd:annotation>
-            </xsd:enumeration>
-            <xsd:enumeration value="OVERFLOW_TO_DISK">
-                <xsd:annotation>
-                    <xsd:documentation><![CDATA[
+				</xsd:annotation>
+			</xsd:enumeration>
+			<xsd:enumeration value="OVERFLOW_TO_DISK">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
 The LRU (least-recently-used) region entry values are written to disk and nulled-out in the member to 
 reclaim memory.
 							]]></xsd:documentation>
-                </xsd:annotation>
-            </xsd:enumeration>
-        </xsd:restriction>
-    </xsd:simpleType>
-    <xsd:complexType name="diskStoreType">
-        <xsd:sequence>
-            <xsd:element name="disk-dir" minOccurs="0"
-                maxOccurs="unbounded">
-                <xsd:complexType>
-                    <xsd:attribute name="location" type="xsd:string"
-                        use="required">
-                        <xsd:annotation>
-                            <xsd:documentation><![CDATA[
+				</xsd:annotation>
+			</xsd:enumeration>
+		</xsd:restriction>
+	</xsd:simpleType>
+	<!-- -->
+	<xsd:complexType name="baseDiskStoreType">
+		<xsd:sequence>
+			<xsd:element name="disk-dir" minOccurs="0" maxOccurs="unbounded">
+				<xsd:complexType>
+					<xsd:attribute name="location" type="xsd:string" use="required">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
 Directory on the file system for storing data.
 
 Note: the directory must already exist.						
 							]]></xsd:documentation>
-                        </xsd:annotation>
-                    </xsd:attribute>
-                    <xsd:attribute name="max-size" type="xsd:string"
-                        default="10240">
-                        <xsd:annotation>
-                            <xsd:documentation><![CDATA[
-The maximum size (in megabytes) of data stored in each directory. Default is 10240 MB (10 gigabytes). 
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="max-size" type="xsd:string" default="2147483647">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
+The maximum size (in megabytes) of data stored in each directory. Default value is 2,147,483,647 which is two petabytes.
 							]]></xsd:documentation>
-                        </xsd:annotation>
-                    </xsd:attribute>
-                </xsd:complexType>
-            </xsd:element>
-        </xsd:sequence>
-        <xsd:attribute name="synchronous-write" type="xsd:string"
-            default="false">
-            <xsd:annotation>
-                <xsd:documentation><![CDATA[
-Indicates whether the writing to the disk si synchronous or not. Default is false, meaning asynchronous writing.
-				]]></xsd:documentation>
-            </xsd:annotation>
-        </xsd:attribute>
-        <xsd:attribute name="auto-compact" type="xsd:string"
-            default="true">
-            <xsd:annotation>
-                <xsd:documentation><![CDATA[
+						</xsd:annotation>
+					</xsd:attribute>
+				</xsd:complexType>
+			</xsd:element>
+		</xsd:sequence>
+		<xsd:attribute name="auto-compact" type="xsd:string" default="true">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
 Indicates whether or not the operation logs are automatically compacted or not. Default is true.
 				]]></xsd:documentation>
-            </xsd:annotation>
-        </xsd:attribute>
-        <xsd:attribute name="max-oplog-size" type="xsd:string"
-            default="1024">
-            <xsd:annotation>
-                <xsd:documentation><![CDATA[
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="max-oplog-size" type="xsd:string" default="1024">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
 Sets the maximum size in megabytes a single oplog (operation log) is allowed to be. When an oplog is created this 
 amount of file space will be immediately reserved. 
 				]]></xsd:documentation>
-            </xsd:annotation>
-        </xsd:attribute>
-        <xsd:attribute name="time-interval" type="xsd:string"
-            default="1">
-            <xsd:annotation>
-                <xsd:documentation><![CDATA[
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="time-interval" type="xsd:string" default="1000">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
 Sets the number of milliseconds that can elapse before unwritten data is written to disk. 
 It is considered only for asynchronous writing. 
 				]]></xsd:documentation>
-            </xsd:annotation>
-        </xsd:attribute>
-        <xsd:attribute name="queue-size" type="xsd:string"
-            default="0">
-            <xsd:annotation>
-                <xsd:documentation><![CDATA[
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="queue-size" type="xsd:string" default="0">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
 The maximum number of operations that can be asynchronously queued. Once this many pending async operations have been 
 queued async ops will begin blocking until some of the queued ops have been flushed to disk.
 Considered only for asynchronous writing.
 				]]></xsd:documentation>
-            </xsd:annotation>
-        </xsd:attribute>
-        <!-- <xsd:attribute name="compaction-threshold" default="50"> <xsd:annotation>
-            <xsd:documentation><![CDATA[ Sets the threshold at which an oplog will become
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="compaction-threshold" default="50">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[ Sets the threshold at which an oplog will become
             compactable. Until it reaches this threshold the oplog will not be compacted.
             The threshold is a percentage in the range 0..100. When the amount of garbage
             in an oplog exceeds this percentage then when a compaction is done this garbage
             will be cleaned up freeing up disk space. Garbage is created by entry destroys,
-            entry updates, and region destroys. ]]> </xsd:documentation> </xsd:annotation>
-            <xsd:simpleType> <xsd:restriction base="xsd:short"> <xsd:minExclusive value="0"/>
-            <xsd:maxExclusive value="100"/> </xsd:restriction> </xsd:simpleType> </xsd:attribute> -->
-    </xsd:complexType>
-    <!-- -->
-    <xsd:element name="client-region">
-        <xsd:annotation>
-            <xsd:documentation
-                source="org.springframework.data.gemfire.client.ClientRegionFactoryBean"><![CDATA[
+            entry updates, and region destroys. ]]></xsd:documentation>
+			</xsd:annotation>
+			<xsd:simpleType>
+				<xsd:restriction base="xsd:short">
+					<xsd:minInclusive value="0"/>
+					<xsd:maxInclusive value="100"/>
+				</xsd:restriction>
+			</xsd:simpleType>
+		</xsd:attribute>
+		<xsd:attribute name="allow-force-compaction" type="xsd:string" default="false">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+Indicates whether forced compaction is allowed for regions using this disk store
+				 ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="write-buffer-size" type="xsd:string" default="32768">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+Indicates the write buffer size in bytes
+				 ]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:complexType>
+	<!-- -->
+	<xsd:complexType name="diskStoreType">
+		<xsd:complexContent>
+			<xsd:extension base="baseDiskStoreType">
+				<xsd:attribute name="id" type="xsd:ID" use="required">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+The name of the disk store bean definition. This is also used as the disk store name]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:attribute>
+			    <xsd:attribute name="cache-ref" type="xsd:string" use="optional" default="gemfire-cache">
+				  <xsd:annotation>
+					 <xsd:documentation><![CDATA[The name of the bean defining the GemFire cache (by default 'gemfire-cache').]]></xsd:documentation>
+				 </xsd:annotation>
+			</xsd:attribute>				
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!-- -->
+	<xsd:element name="disk-store" type="diskStoreType"/>
+	<!-- -->
+	<xsd:element name="client-region">
+		<xsd:annotation>
+			<xsd:documentation source="org.springframework.data.gemfire.client.ClientRegionFactoryBean"><![CDATA[
 Defines a GemFire client region instance. A client region is connected to a (long-lived) farm of GemFire servers from
 which it receives its data. The client can hold some data locally or forward all requests to the server.
 			]]></xsd:documentation>
-            <xsd:appinfo>
-                <tool:annotation>
-                    <tool:exports type="com.gemstone.gemfire.cache.Region" />
-                </tool:annotation>
-            </xsd:appinfo>
-        </xsd:annotation>
-        <xsd:complexType>
-            <xsd:complexContent>
-                <xsd:extension base="readOnlyRegionType">
-                    <xsd:sequence>
-                        <xsd:choice minOccurs="0" maxOccurs="unbounded">
-                            <xsd:element name="key-interest">
-                                <xsd:annotation>
-                                    <xsd:documentation><![CDATA[
+			<xsd:appinfo>
+				<tool:annotation>
+					<tool:exports type="com.gemstone.gemfire.cache.Region"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="readOnlyRegionType">
+					<xsd:sequence>
+						<xsd:choice minOccurs="0" maxOccurs="unbounded">
+							<xsd:element name="key-interest">
+								<xsd:annotation>
+									<xsd:documentation><![CDATA[
 Key based interest. If the key is a List, then all the keys in the List will be registered. The key can also be the 
 special token 'ALL_KEYS', which will register interest in all keys in the region. In effect, this will cause an update 
 to any key in this region in the CacheServer to be pushed to the client. 
 									]]></xsd:documentation>
-                                </xsd:annotation>
-                                <xsd:complexType>
-                                    <xsd:complexContent>
-                                        <xsd:extension
-                                            base="interestType">
-                                            <xsd:sequence
-                                                minOccurs="0" maxOccurs="1">
-                                                <xsd:any
-                                                    namespace="##other"
-                                                    processContents="skip"
-                                                    minOccurs="0"
-                                                    maxOccurs="unbounded">
-                                                    <xsd:annotation>
-                                                        <xsd:documentation><![CDATA[
+								</xsd:annotation>
+								<xsd:complexType>
+									<xsd:complexContent>
+										<xsd:extension base="interestType">
+											<xsd:sequence minOccurs="0" maxOccurs="1">
+												<xsd:any namespace="##other" processContents="skip" minOccurs="0" maxOccurs="unbounded">
+													<xsd:annotation>
+														<xsd:documentation><![CDATA[
 Inner bean definition of the client key interest.
 														]]></xsd:documentation>
-                                                    </xsd:annotation>
-                                                </xsd:any>
-                                            </xsd:sequence>
-                                            <xsd:attribute
-                                                name="key-ref" type="xsd:string"
-                                                use="optional">
-                                                <xsd:annotation>
-                                                    <xsd:documentation><![CDATA[
+													</xsd:annotation>
+												</xsd:any>
+											</xsd:sequence>
+											<xsd:attribute name="key-ref" type="xsd:string" use="optional">
+												<xsd:annotation>
+													<xsd:documentation><![CDATA[
 The name of the client key interest bean referred by this declaration. Used as a convenience method. If no reference exists, 
 use the inner bean declaration.
 													]]></xsd:documentation>
-                                                </xsd:annotation>
-                                            </xsd:attribute>
-                                        </xsd:extension>
-                                    </xsd:complexContent>
-                                </xsd:complexType>
-                            </xsd:element>
-                            <xsd:element name="regex-interest">
-                                <xsd:annotation>
-                                    <xsd:documentation><![CDATA[
+												</xsd:annotation>
+											</xsd:attribute>
+										</xsd:extension>
+									</xsd:complexContent>
+								</xsd:complexType>
+							</xsd:element>
+							<xsd:element name="regex-interest">
+								<xsd:annotation>
+									<xsd:documentation><![CDATA[
 Regular expression based interest. If the pattern is '.*' then all keys of any type will be pushed to the client. 
 									]]></xsd:documentation>
-                                </xsd:annotation>
-                                <xsd:complexType>
-                                    <xsd:complexContent>
-                                        <xsd:extension
-                                            base="interestType">
-                                            <xsd:attribute
-                                                name="pattern" type="xsd:string" />
-                                        </xsd:extension>
-                                    </xsd:complexContent>
-                                </xsd:complexType>
-                            </xsd:element>
-                        </xsd:choice>
-                        <xsd:element name="eviction"
-                            minOccurs="0" maxOccurs="1">
-                            <xsd:annotation>
-                                <xsd:documentation><![CDATA[
+								</xsd:annotation>
+								<xsd:complexType>
+									<xsd:complexContent>
+										<xsd:extension base="interestType">
+											<xsd:attribute name="pattern" type="xsd:string"/>
+										</xsd:extension>
+									</xsd:complexContent>
+								</xsd:complexType>
+							</xsd:element>
+						</xsd:choice>
+						<xsd:element name="eviction" minOccurs="0" maxOccurs="1">
+							<xsd:annotation>
+								<xsd:documentation><![CDATA[
 Eviction policy for the partitioned region.
 								]]></xsd:documentation>
-                            </xsd:annotation>
-                            <xsd:complexType>
-                                <xsd:complexContent>
-                                    <xsd:extension base="evictionType">
-                                        <xsd:attribute
-                                            name="action" type="evictionActionType"
-                                            default="LOCAL_DESTROY">
-                                            <xsd:annotation>
-                                                <xsd:documentation><![CDATA[
+							</xsd:annotation>
+							<xsd:complexType>
+								<xsd:complexContent>
+									<xsd:extension base="evictionType">
+										<xsd:attribute name="action" type="evictionActionType" default="LOCAL_DESTROY">
+											<xsd:annotation>
+												<xsd:documentation><![CDATA[
 The action to take when performing eviction.
 												]]></xsd:documentation>
-                                            </xsd:annotation>
-                                        </xsd:attribute>
-                                    </xsd:extension>
-                                </xsd:complexContent>
-                            </xsd:complexType>
-                        </xsd:element>
-                    </xsd:sequence>
-                    <xsd:attribute name="data-policy" use="optional"
-                        default="NORMAL">
-                        <xsd:annotation>
-                            <xsd:documentation><![CDATA[
+											</xsd:annotation>
+										</xsd:attribute>
+									</xsd:extension>
+								</xsd:complexContent>
+							</xsd:complexType>
+						</xsd:element>
+					</xsd:sequence>
+					<xsd:attribute name="data-policy" type="baseDataPolicyType" use="optional" default="NORMAL">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
 The data policy for this client. Can be either 'EMPTY' or 'NORMAL' (the default). In case persistence or overflow are
 configured for this region, this parameter will be ignored.
 
@@ -1158,556 +1228,468 @@ EMPTY - causes data to never be stored in local memory. The region will always a
 NORMAL - causes data that this region is interested in to be stored in local memory. It allows the contents in this 
 cache to differ from other caches.  
  							]]></xsd:documentation>
-                        </xsd:annotation>
-                        <xsd:simpleType>
-                            <xsd:restriction base="xsd:string">
-                                <xsd:enumeration value="EMPTY" />
-                                <xsd:enumeration value="NORMAL" />
-                            </xsd:restriction>
-                        </xsd:simpleType>
-                    </xsd:attribute>
-                    <xsd:attribute name="pool-name" type="xsd:string"
-                        use="optional">
-                        <xsd:annotation>
-                            <xsd:documentation><![CDATA[
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="pool-name" type="xsd:string" use="optional">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
 The name of the pool used by this client. If not set, a default pool (initialized when using client-cache) will be used.
  							]]></xsd:documentation>
-                        </xsd:annotation>
-                    </xsd:attribute>
-                    <xsd:attribute name="shortcut" use="optional">
-                        <xsd:annotation>
-                            <xsd:documentation><![CDATA[
+						</xsd:annotation>
+					</xsd:attribute>
+					<xsd:attribute name="shortcut" use="optional">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
 The ClientRegionShortcut for this region. Allows easy initialization of the region based on defaults.
  							]]></xsd:documentation>
-                        </xsd:annotation>
-                        <xsd:simpleType>
-                            <xsd:restriction base="xsd:string">
-                                <xsd:enumeration value="PROXY" />
-                                <xsd:enumeration value="CACHING_PROXY" />
-                                <xsd:enumeration
-                                    value="CACHING_PROXY_HEAP_LRU" />
-                                <xsd:enumeration
-                                    value="CACHING_PROXY_OVERFLOW" />
-                                <xsd:enumeration value="LOCAL" />
-                                <xsd:enumeration value="LOCAL_PERSISTENT" />
-                                <xsd:enumeration value="LOCAL_HEAP_LRU" />
-                                <xsd:enumeration value="LOCAL_OVERFLOW" />
-                                <xsd:enumeration
-                                    value="LOCAL_PERSISTENT_OVERFLOW" />
-                            </xsd:restriction>
-                        </xsd:simpleType>
-                    </xsd:attribute>
-                </xsd:extension>
-            </xsd:complexContent>
-        </xsd:complexType>
-    </xsd:element>
-    <!-- -->
-    <xsd:complexType name="connectionType">
-        <xsd:attribute name="host" type="xsd:string">
-            <xsd:annotation>
-                <xsd:documentation><![CDATA[
+						</xsd:annotation>
+						<xsd:simpleType>
+							<xsd:restriction base="xsd:string">
+								<xsd:enumeration value="PROXY"/>
+								<xsd:enumeration value="CACHING_PROXY"/>
+								<xsd:enumeration value="CACHING_PROXY_HEAP_LRU"/>
+								<xsd:enumeration value="CACHING_PROXY_OVERFLOW"/>
+								<xsd:enumeration value="LOCAL"/>
+								<xsd:enumeration value="LOCAL_PERSISTENT"/>
+								<xsd:enumeration value="LOCAL_HEAP_LRU"/>
+								<xsd:enumeration value="LOCAL_OVERFLOW"/>
+								<xsd:enumeration value="LOCAL_PERSISTENT_OVERFLOW"/>
+							</xsd:restriction>
+						</xsd:simpleType>
+					</xsd:attribute>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<!-- -->
+	<xsd:complexType name="connectionType">
+		<xsd:attribute name="host" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
 The host name or ip address of the connection.				
 				]]></xsd:documentation>
-            </xsd:annotation>
-        </xsd:attribute>
-        <xsd:attribute name="port">
-            <xsd:annotation>
-                <xsd:documentation><![CDATA[
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="port">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
 The port number of the connection (between 1 and 65535 inclusive).				
 				]]></xsd:documentation>
-            </xsd:annotation>
-            <xsd:simpleType>
-                <xsd:restriction base="xsd:string" />
-            </xsd:simpleType>
-        </xsd:attribute>
-    </xsd:complexType>
-    <!-- -->
-    <xsd:complexType name="interestType" abstract="true">
-        <xsd:attribute name="durable" type="xsd:string"
-            use="optional" default="false">
-            <xsd:annotation>
-                <xsd:documentation><![CDATA[
+			</xsd:annotation>
+			<xsd:simpleType>
+				<xsd:restriction base="xsd:string"/>
+			</xsd:simpleType>
+		</xsd:attribute>
+	</xsd:complexType>
+	<!-- -->
+	<xsd:complexType name="interestType" abstract="true">
+		<xsd:attribute name="durable" type="xsd:string" use="optional" default="false">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
 Indicates whether or not the registered interest is durable or not. Default is false.
 				]]></xsd:documentation>
-            </xsd:annotation>
-        </xsd:attribute>
-        <xsd:attribute name="result-policy" use="optional"
-            default="KEYS_VALUES">
-            <xsd:annotation>
-                <xsd:documentation><![CDATA[
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="result-policy" use="optional" default="KEYS_VALUES">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
 The result policy for this interest. Can be one of 'KEYS' or 'KEYS_VALUES' (the default) or 'NONE'. 
 
 KEYS - Initializes the local cache with the keys satisfying the request.
 KEYS-VALUES - initializes the local cache with the keys and current values satisfying the request.
 NONE -  Does not initialize the local cache.
 					]]></xsd:documentation>
-            </xsd:annotation>
-            <xsd:simpleType>
-                <xsd:restriction base="xsd:string">
-                    <xsd:enumeration value="KEYS" />
-                    <xsd:enumeration value="KEYS_VALUES" />
-                    <xsd:enumeration value="NONE" />
-                </xsd:restriction>
-            </xsd:simpleType>
-        </xsd:attribute>
-        <xsd:attribute name="receive-values" type="xsd:string"
-            use="optional" default="true">
-            <xsd:annotation>
-                <xsd:documentation><![CDATA[
+			</xsd:annotation>
+			<xsd:simpleType>
+				<xsd:restriction base="xsd:string">
+					<xsd:enumeration value="KEYS"/>
+					<xsd:enumeration value="KEYS_VALUES"/>
+					<xsd:enumeration value="NONE"/>
+				</xsd:restriction>
+			</xsd:simpleType>
+		</xsd:attribute>
+		<xsd:attribute name="receive-values" type="xsd:string" use="optional" default="true">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
 Indicates whether values are received with create and update events on keys of interest (true) 
 or only invalidations are received and the value will be received on the next get instead (false).
 Default is true.
 				]]></xsd:documentation>
-            </xsd:annotation>
-        </xsd:attribute>
-    </xsd:complexType>
-    <!-- -->
-    <xsd:element name="pool">
-        <xsd:annotation>
-            <xsd:documentation
-                source="org.springframework.data.gemfire.client.PoolFactoryBean"><![CDATA[
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:complexType>
+	<!-- -->
+	<xsd:element name="pool">
+		<xsd:annotation>
+			<xsd:documentation source="org.springframework.data.gemfire.client.PoolFactoryBean"><![CDATA[
 Defines a pool for connections from a client to a set of GemFire Cache Servers.
 
 Note that in order to instantiate a pool, a GemFire cache needs to be already started.
 			]]></xsd:documentation>
-            <xsd:appinfo>
-                <tool:annotation>
-                    <tool:exports
-                        type="com.gemstone.gemfire.cache.client.Pool" />
-                </tool:annotation>
-            </xsd:appinfo>
-        </xsd:annotation>
-        <xsd:complexType>
-            <xsd:choice minOccurs="1" maxOccurs="1">
-                <xsd:element name="locator" type="connectionType"
-                    minOccurs="1" maxOccurs="unbounded" />
-                <xsd:element name="server" type="connectionType"
-                    minOccurs="1" maxOccurs="unbounded" />
-            </xsd:choice>
-            <xsd:attribute name="id" type="xsd:ID" use="optional">
-                <xsd:annotation>
-                    <xsd:documentation><![CDATA[
+			<xsd:appinfo>
+				<tool:annotation>
+					<tool:exports type="com.gemstone.gemfire.cache.client.Pool"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:choice minOccurs="1" maxOccurs="1">
+				<xsd:element name="locator" type="connectionType" minOccurs="1" maxOccurs="unbounded"/>
+				<xsd:element name="server" type="connectionType" minOccurs="1" maxOccurs="unbounded"/>
+			</xsd:choice>
+			<xsd:attribute name="id" type="xsd:ID" use="optional">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
 The name of the pool definition (by default "gemfire-pool").]]></xsd:documentation>
-                </xsd:annotation>
-            </xsd:attribute>
-            <xsd:attribute name="free-connection-timeout"
-                type="xsd:string" use="optional" />
-            <xsd:attribute name="idle-timeout" type="xsd:string"
-                use="optional" />
-            <xsd:attribute name="load-conditioning-interval"
-                type="xsd:string" use="optional" />
-            <xsd:attribute name="max-connections" type="xsd:string"
-                use="optional" />
-            <xsd:attribute name="min-connections" type="xsd:string"
-                use="optional" />
-            <xsd:attribute name="multi-user-authentication"
-                type="xsd:string" use="optional" />
-            <xsd:attribute name="ping-interval" type="xsd:string"
-                use="optional" />
-            <xsd:attribute name="pr-single-hop-enabled"
-                type="xsd:string" use="optional" />
-            <xsd:attribute name="read-timeout" type="xsd:string"
-                use="optional" />
-            <xsd:attribute name="retry-attempts" type="xsd:string"
-                use="optional" />
-            <xsd:attribute name="server-group" type="xsd:string"
-                use="optional" />
-            <xsd:attribute name="socket-buffer-size" type="xsd:string"
-                use="optional" />
-            <xsd:attribute name="statistic-interval" type="xsd:string"
-                use="optional" />
-            <xsd:attribute name="subscription-ack-interval"
-                type="xsd:string" use="optional" />
-            <xsd:attribute name="subscription-enabled"
-                type="xsd:string" use="optional" />
-            <xsd:attribute name="subscription-message-tracking-timeout"
-                type="xsd:string" use="optional" />
-            <xsd:attribute name="subscription-redundancy"
-                type="xsd:string" use="optional" />
-            <xsd:attribute name="thread-local-connections"
-                type="xsd:string" use="optional" />
-        </xsd:complexType>
-    </xsd:element>
-    <!-- -->
-    <xsd:element name="cache-server">
-        <xsd:annotation>
-            <xsd:documentation
-                source="org.springframework.data.gemfire.server.CacheServerFactoryBean"><![CDATA[
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="free-connection-timeout" type="xsd:string" use="optional"/>
+			<xsd:attribute name="idle-timeout" type="xsd:string" use="optional"/>
+			<xsd:attribute name="load-conditioning-interval" type="xsd:string" use="optional"/>
+			<xsd:attribute name="max-connections" type="xsd:string" use="optional"/>
+			<xsd:attribute name="min-connections" type="xsd:string" use="optional"/>
+			<xsd:attribute name="multi-user-authentication" type="xsd:string" use="optional"/>
+			<xsd:attribute name="ping-interval" type="xsd:string" use="optional"/>
+			<xsd:attribute name="pr-single-hop-enabled" type="xsd:string" use="optional"/>
+			<xsd:attribute name="read-timeout" type="xsd:string" use="optional"/>
+			<xsd:attribute name="retry-attempts" type="xsd:string" use="optional"/>
+			<xsd:attribute name="server-group" type="xsd:string" use="optional"/>
+			<xsd:attribute name="socket-buffer-size" type="xsd:string" use="optional"/>
+			<xsd:attribute name="statistic-interval" type="xsd:string" use="optional"/>
+			<xsd:attribute name="subscription-ack-interval" type="xsd:string" use="optional"/>
+			<xsd:attribute name="subscription-enabled" type="xsd:string" use="optional"/>
+			<xsd:attribute name="subscription-message-tracking-timeout" type="xsd:string" use="optional"/>
+			<xsd:attribute name="subscription-redundancy" type="xsd:string" use="optional"/>
+			<xsd:attribute name="thread-local-connections" type="xsd:string" use="optional"/>
+		</xsd:complexType>
+	</xsd:element>
+	<!-- -->
+	<xsd:element name="cache-server">
+		<xsd:annotation>
+			<xsd:documentation source="org.springframework.data.gemfire.server.CacheServerFactoryBean"><![CDATA[
 Defines a Cache Server for feeding data to remote gemfire clients to a server GemFire Cache Servers.
 Note: In order to instantiate a cacheserver, a GemFire cache needs to be avaialble in the VM.
 			]]></xsd:documentation>
-            <xsd:appinfo>
-                <tool:annotation>
-                    <tool:exports
-                        type="com.gemstone.gemfire.cache.server.CacheServer" />
-                </tool:annotation>
-            </xsd:appinfo>
-        </xsd:annotation>
-        <xsd:complexType>
-            <xsd:sequence minOccurs="0" maxOccurs="1">
-                <xsd:element name="subscription-config"
-                    minOccurs="0" maxOccurs="1">
-                    <xsd:annotation>
-                        <xsd:documentation><![CDATA[
+			<xsd:appinfo>
+				<tool:annotation>
+					<tool:exports type="com.gemstone.gemfire.cache.server.CacheServer"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:sequence minOccurs="0" maxOccurs="1">
+				<xsd:element name="subscription-config" minOccurs="0" maxOccurs="1">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
 The client subscription configuration that is used to control a clients use of server resources towards notification queues.				
 				]]></xsd:documentation>
-                    </xsd:annotation>
-                    <xsd:complexType>
-                        <xsd:attribute name="eviction-type"
-                            use="optional" default="NONE">
-                            <xsd:simpleType>
-                                <xsd:restriction base="xsd:string">
-                                    <xsd:enumeration
-                                        value="NONE" />
-                                    <xsd:enumeration
-                                        value="MEM" />
-                                    <xsd:enumeration
-                                        value="ENTRY" />
-                                </xsd:restriction>
-                            </xsd:simpleType>
-                        </xsd:attribute>
-                        <xsd:attribute name="capacity"
-                            type="xsd:string" use="optional" default="1" />
-                        <xsd:attribute name="disk-store"
-                            type="xsd:string" use="optional" default="." />
-                    </xsd:complexType>
-                </xsd:element>
-            </xsd:sequence>
-            <xsd:attribute name="id" type="xsd:ID" use="optional">
-                <xsd:annotation>
-                    <xsd:documentation><![CDATA[The name of the cache server definition (by default "gemfire-server").]]></xsd:documentation>
-                </xsd:annotation>
-            </xsd:attribute>
-            <xsd:attribute name="auto-startup" type="xsd:string"
-                use="optional" default="true" />
-            <xsd:attribute name="bind-address" type="xsd:string"
-                use="optional" />
-            <xsd:attribute name="port" type="xsd:string"
-                use="optional" default="40404">
-                <xsd:annotation>
-                    <xsd:documentation><![CDATA[The port number of the server.]]></xsd:documentation>
-                </xsd:annotation>
-            </xsd:attribute>
-            <xsd:attribute name="host-name-for-clients"
-                type="xsd:string" use="optional" />
-            <xsd:attribute name="load-poll-interval" type="xsd:string"
-                use="optional" default="5000" />
-            <xsd:attribute name="max-connections" type="xsd:string"
-                use="optional" default="800" />
-            <xsd:attribute name="max-threads" type="xsd:string"
-                use="optional" default="0" />
-            <xsd:attribute name="max-message-count" type="xsd:string"
-                use="optional" default="230000" />
-            <xsd:attribute name="max-time-between-pings"
-                type="xsd:string" use="optional" default="60000" />
-            <xsd:attribute name="message-time-to-live"
-                type="xsd:string" use="optional" default="180" />
-            <xsd:attribute name="socket-buffer-size" type="xsd:string"
-                use="optional" default="32768" />
-            <xsd:attribute name="notify-by-subscription"
-                type="xsd:string" use="optional" default="true" />
-            <xsd:attribute name="groups" type="xsd:string"
-                use="optional" default="">
-                <xsd:annotation>
-                    <xsd:documentation><![CDATA[
+					</xsd:annotation>
+					<xsd:complexType>
+						<xsd:attribute name="eviction-type" use="optional" default="NONE">
+							<xsd:simpleType>
+								<xsd:restriction base="xsd:string">
+									<xsd:enumeration value="NONE"/>
+									<xsd:enumeration value="MEM"/>
+									<xsd:enumeration value="ENTRY"/>
+								</xsd:restriction>
+							</xsd:simpleType>
+						</xsd:attribute>
+						<xsd:attribute name="capacity" type="xsd:string" use="optional" default="1"/>
+						<xsd:attribute name="disk-store" type="xsd:string" use="optional" default="."/>
+					</xsd:complexType>
+				</xsd:element>
+			</xsd:sequence>
+			<xsd:attribute name="id" type="xsd:ID" use="optional">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[The name of the cache server definition (by default "gemfire-server").]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="auto-startup" type="xsd:string" use="optional" default="true"/>
+			<xsd:attribute name="bind-address" type="xsd:string" use="optional"/>
+			<xsd:attribute name="port" type="xsd:string" use="optional" default="40404">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[The port number of the server.]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="host-name-for-clients" type="xsd:string" use="optional"/>
+			<xsd:attribute name="load-poll-interval" type="xsd:string" use="optional" default="5000"/>
+			<xsd:attribute name="max-connections" type="xsd:string" use="optional" default="800"/>
+			<xsd:attribute name="max-threads" type="xsd:string" use="optional" default="0"/>
+			<xsd:attribute name="max-message-count" type="xsd:string" use="optional" default="230000"/>
+			<xsd:attribute name="max-time-between-pings" type="xsd:string" use="optional" default="60000"/>
+			<xsd:attribute name="message-time-to-live" type="xsd:string" use="optional" default="180"/>
+			<xsd:attribute name="socket-buffer-size" type="xsd:string" use="optional" default="32768"/>
+			<xsd:attribute name="notify-by-subscription" type="xsd:string" use="optional" default="true"/>
+			<xsd:attribute name="groups" type="xsd:string" use="optional" default="">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
 The server groups that this server will be a member of given as a comma separated values list.				
 				]]></xsd:documentation>
-                </xsd:annotation>
-            </xsd:attribute>
-            <xsd:attribute name="load-probe-ref" type="xsd:string"
-                use="optional">
-                <xsd:annotation>
-                    <xsd:documentation><![CDATA[The name of the bean defining the CacheServer Load Probe.]]></xsd:documentation>
-                </xsd:annotation>
-            </xsd:attribute>
-            <xsd:attribute name="cache-ref" type="xsd:string"
-                use="optional" default="gemfire-cache">
-                <xsd:annotation>
-                    <xsd:documentation><![CDATA[The name of the bean defining the GemFire cache (by default 'gemfire-cache').]]></xsd:documentation>
-                </xsd:annotation>
-            </xsd:attribute>
-        </xsd:complexType>
-    </xsd:element>
-    <!-- -->
-    <xsd:element name="cq-listener-container">
-        <xsd:annotation>
-            <xsd:documentation><![CDATA[
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="load-probe-ref" type="xsd:string" use="optional">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[The name of the bean defining the CacheServer Load Probe.]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="cache-ref" type="xsd:string" use="optional" default="gemfire-cache">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[The name of the bean defining the GemFire cache (by default 'gemfire-cache').]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+		</xsd:complexType>
+	</xsd:element>
+	<!-- -->
+	<xsd:element name="cq-listener-container">
+		<xsd:annotation>
+			<xsd:documentation><![CDATA[
 Container for continuous query listeners. All listeners will be hosted by the same container.
 	      ]]></xsd:documentation>
-            <xsd:appinfo>
-                <tool:annotation>
-                    <tool:exports
-                        type="org.springframework.data.gemfire.listener.ContinuousQueryListenerContainer" />
-                </tool:annotation>
-            </xsd:appinfo>
-        </xsd:annotation>
-        <xsd:complexType>
-            <xsd:sequence>
-                <xsd:element name="listener" type="listenerType"
-                    minOccurs="0" maxOccurs="unbounded" />
-            </xsd:sequence>
-            <xsd:attribute name="cache" type="xsd:string"
-                default="gemfire-cache">
-                <xsd:annotation>
-                    <xsd:documentation><![CDATA[
+			<xsd:appinfo>
+				<tool:annotation>
+					<tool:exports type="org.springframework.data.gemfire.listener.ContinuousQueryListenerContainer"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:sequence>
+				<xsd:element name="listener" type="listenerType" minOccurs="0" maxOccurs="unbounded"/>
+			</xsd:sequence>
+			<xsd:attribute name="cache" type="xsd:string" default="gemfire-cache">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
 A reference (by name) to the GemFire cache bean. Default is "gemfire-cache".
 	          ]]></xsd:documentation>
-                    <xsd:appinfo>
-                        <tool:annotation kind="ref">
-                            <tool:expected-type
-                                type="com.gemstone.gemfire.cache.RegionService" />
-                        </tool:annotation>
-                    </xsd:appinfo>
-                </xsd:annotation>
-            </xsd:attribute>
-            <xsd:attribute name="task-executor" type="xsd:string">
-                <xsd:annotation>
-                    <xsd:documentation><![CDATA[
+					<xsd:appinfo>
+						<tool:annotation kind="ref">
+							<tool:expected-type type="com.gemstone.gemfire.cache.RegionService"/>
+						</tool:annotation>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="task-executor" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
 A reference to a Spring TaskExecutor (or standard JDK 1.5 Executor) for executing
 GemFire listener invokers. Default is a SimpleAsyncTaskExecutor.
 	          ]]></xsd:documentation>
-                    <xsd:appinfo>
-                        <tool:annotation kind="ref">
-                            <tool:expected-type
-                                type="java.util.concurrent.Executor" />
-                        </tool:annotation>
-                    </xsd:appinfo>
-                </xsd:annotation>
-            </xsd:attribute>
-            <xsd:attribute name="phase" type="xsd:string">
-                <xsd:annotation>
-                    <xsd:documentation><![CDATA[
+					<xsd:appinfo>
+						<tool:annotation kind="ref">
+							<tool:expected-type type="java.util.concurrent.Executor"/>
+						</tool:annotation>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="phase" type="xsd:string">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
 The lifecycle phase within which this container should start and stop. The lower
 the value the earlier this container will start and the later it will stop. The
 default is Integer.MAX_VALUE meaning the container will start as late as possible
 and stop as soon as possible.
 	          ]]></xsd:documentation>
-                </xsd:annotation>
-            </xsd:attribute>
-            <xsd:attribute name="pool-name" type="xsd:string"
-                use="optional">
-                <xsd:annotation>
-                    <xsd:documentation><![CDATA[
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="pool-name" type="xsd:string" use="optional">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
 The name of the pool used by the container.
  						]]></xsd:documentation>
-                </xsd:annotation>
-            </xsd:attribute>
-        </xsd:complexType>
-    </xsd:element>
-    <!-- -->
-    <xsd:complexType name="listenerType">
-        <xsd:attribute name="ref" type="xsd:string" use="required">
-            <xsd:annotation>
-                <xsd:documentation><![CDATA[
+				</xsd:annotation>
+			</xsd:attribute>
+		</xsd:complexType>
+	</xsd:element>
+	<!-- -->
+	<xsd:complexType name="listenerType">
+		<xsd:attribute name="ref" type="xsd:string" use="required">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
 The bean name of the listener object, implementing the ContinuousQueryListener interface or defining the specified listener method.
 Required.
 	        ]]></xsd:documentation>
-                <xsd:appinfo>
-                    <tool:annotation kind="ref" />
-                </xsd:appinfo>
-            </xsd:annotation>
-        </xsd:attribute>
-        <xsd:attribute name="query" type="xsd:string" use="required">
-            <xsd:annotation>
-                <xsd:documentation><![CDATA[
+				<xsd:appinfo>
+					<tool:annotation kind="ref"/>
+				</xsd:appinfo>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="query" type="xsd:string" use="required">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
 The query for the GemFire continuous query. 
 	        ]]></xsd:documentation>
-            </xsd:annotation>
-        </xsd:attribute>
-        <xsd:attribute name="method" type="xsd:string"
-            use="optional">
-            <xsd:annotation>
-                <xsd:documentation><![CDATA[
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="method" type="xsd:string" use="optional">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
 The name of the listener method to invoke. If not specified, the target bean is supposed to implement the ContinuousQueryListener
 interface or provide a method named 'handleEvent'.
 	        ]]></xsd:documentation>
-            </xsd:annotation>
-        </xsd:attribute>
-        <xsd:attribute name="name" type="xsd:string" use="optional">
-            <xsd:annotation>
-                <xsd:documentation><![CDATA[
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="name" type="xsd:string" use="optional">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
 The name of the resulting GemFire continuous query. Useful for monitoring and statistics querying. 
 	        ]]></xsd:documentation>
-            </xsd:annotation>
-        </xsd:attribute>
-        <xsd:attribute name="durable" type="xsd:string"
-            use="optional">
-            <xsd:annotation>
-                <xsd:documentation><![CDATA[
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="durable" type="xsd:string" use="optional">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
 Whether the resulting GemFire continuous query is durable or not. 
 	        ]]></xsd:documentation>
-            </xsd:annotation>
-        </xsd:attribute>
-    </xsd:complexType>
-    <!-- -->
-    <xsd:element name="index">
-        <xsd:annotation>
-            <xsd:documentation
-                source="org.springframework.data.gemfire.IndexFactoryBean"><![CDATA[
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:complexType>
+	<!-- -->
+	<xsd:element name="index">
+		<xsd:annotation>
+			<xsd:documentation source="org.springframework.data.gemfire.IndexFactoryBean"><![CDATA[
 Defines a GemFire index.
 			]]></xsd:documentation>
-            <xsd:appinfo>
-                <tool:annotation>
-                    <tool:exports
-                        type="com.gemstone.gemfire.cache.query.Index" />
-                </tool:annotation>
-            </xsd:appinfo>
-        </xsd:annotation>
-        <xsd:complexType>
-            <xsd:attribute name="id" type="xsd:ID">
-                <xsd:annotation>
-                    <xsd:documentation><![CDATA[
-The name of the bean index definition. If property 'name' is not set, it will be used as the index name as well.]]></xsd:documentation>
-                </xsd:annotation>
-            </xsd:attribute>
-            <xsd:attribute name="type" use="optional"
-                default="FUNCTIONAL">
-                <xsd:simpleType>
-                    <xsd:restriction base="xsd:string">
-                        <xsd:enumeration value="FUNCTIONAL" />
-                        <xsd:enumeration value="PRIMARY_KEY" />
-                    </xsd:restriction>
-                </xsd:simpleType>
-            </xsd:attribute>
-            <xsd:attribute name="name" type="xsd:string"
-                use="optional">
-                <xsd:annotation>
-                    <xsd:documentation><![CDATA[
+			<xsd:appinfo>
+				<tool:annotation>
+					<tool:exports type="com.gemstone.gemfire.cache.query.Index"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:attribute name="id" type="xsd:ID">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+The name of the index bean definition. If property 'name' is not set, it will be used as the index name as well.]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="type" use="optional" default="FUNCTIONAL">
+				<xsd:simpleType>
+					<xsd:restriction base="xsd:string">
+						<xsd:enumeration value="FUNCTIONAL"/>
+						<xsd:enumeration value="PRIMARY_KEY"/>
+					</xsd:restriction>
+				</xsd:simpleType>
+			</xsd:attribute>
+			<xsd:attribute name="name" type="xsd:string" use="optional">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
 The name of the index.]]></xsd:documentation>
-                </xsd:annotation>
-            </xsd:attribute>
-            <xsd:attribute name="expression" type="xsd:string"
-                use="required" />
-            <xsd:attribute name="from" type="xsd:string"
-                use="required" />
-            <xsd:attribute name="imports" type="xsd:string"
-                use="optional" />
-            <xsd:attribute name="override" type="xsd:string"
-                use="optional" default="true">
-                <xsd:annotation>
-                    <xsd:documentation><![CDATA[
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="expression" type="xsd:string" use="required"/>
+			<xsd:attribute name="from" type="xsd:string" use="required"/>
+			<xsd:attribute name="imports" type="xsd:string" use="optional"/>
+			<xsd:attribute name="override" type="xsd:string" use="optional" default="true">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
 Indicates whether the index is created even if there is an index with the same name (default) or not.]]></xsd:documentation>
-                </xsd:annotation>
-            </xsd:attribute>
-            <xsd:attribute name="cache-ref" type="xsd:string"
-                use="optional" default="gemfire-cache">
-                <xsd:annotation>
-                    <xsd:documentation><![CDATA[
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="cache-ref" type="xsd:string" use="optional" default="gemfire-cache">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
 The name of the bean defining the GemFire cache (by default 'gemfire-cache').
 					]]></xsd:documentation>
-                </xsd:annotation>
-            </xsd:attribute>
-            <xsd:attribute name="pool-name" type="xsd:string"
-                use="optional">
-                <xsd:annotation>
-                    <xsd:documentation><![CDATA[
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="pool-name" type="xsd:string" use="optional">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
 The name of the pool used by the index. Used usually in client scenarios.
 					]]></xsd:documentation>
-                </xsd:annotation>
-            </xsd:attribute>
-        </xsd:complexType>
-    </xsd:element>
-    <!-- Repositories -->
-    <xsd:element name="repositories">
-        <xsd:complexType>
-            <xsd:complexContent>
-                <xsd:extension base="repository:repositories">
-                    <xsd:sequence>
-                        <xsd:element name="repository"
-                            type="gemfire-repository" minOccurs="0"
-                            maxOccurs="unbounded" />
-                    </xsd:sequence>
-                    <xsd:attributeGroup ref="gemfire-repository-attributes" />
-                    <xsd:attributeGroup
-                        ref="repository:repository-attributes" />
-                </xsd:extension>
-            </xsd:complexContent>
-        </xsd:complexType>
-    </xsd:element>
-    <!-- -->
-    <xsd:complexType name="gemfire-repository">
-        <xsd:complexContent>
-            <xsd:extension base="repository:repository">
-                <xsd:attributeGroup ref="gemfire-repository-attributes" />
-                <xsd:attributeGroup ref="repository:repository-attributes" />
-            </xsd:extension>
-        </xsd:complexContent>
-    </xsd:complexType>
-    <!-- -->
-    <xsd:attributeGroup name="gemfire-repository-attributes">
-        <xsd:attribute name="gemfire-template-ref" type="gemfireTemplateRef"
-            default="gemfireTemplate">
-            <xsd:annotation>
-                <xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+		</xsd:complexType>
+	</xsd:element>
+	<!-- Repositories -->
+	<xsd:element name="repositories">
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="repository:repositories">
+					<xsd:sequence>
+						<xsd:element name="repository" type="gemfire-repository" minOccurs="0" maxOccurs="unbounded"/>
+					</xsd:sequence>
+					<xsd:attributeGroup ref="gemfire-repository-attributes"/>
+					<xsd:attributeGroup ref="repository:repository-attributes"/>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+	<!-- -->
+	<xsd:complexType name="gemfire-repository">
+		<xsd:complexContent>
+			<xsd:extension base="repository:repository">
+				<xsd:attributeGroup ref="gemfire-repository-attributes"/>
+				<xsd:attributeGroup ref="repository:repository-attributes"/>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
+	<!-- -->
+	<xsd:attributeGroup name="gemfire-repository-attributes">
+		<xsd:attribute name="gemfire-template-ref" type="gemfireTemplateRef" default="gemfireTemplate">
+			<xsd:annotation>
+				<xsd:documentation>
                     The reference to a GemfireTemplate.
                     Will default to 'gemfireTemplate'.
                 </xsd:documentation>
-            </xsd:annotation>
-        </xsd:attribute>
-    </xsd:attributeGroup>
-    <!-- -->
-    <xsd:simpleType name="gemfireTemplateRef">
-        <xsd:annotation>
-            <xsd:appinfo>
-                <tool:annotation kind="ref">
-                    <tool:assignable-to
-                        type="org.springframework.data.gemfire.GemfireTemplate" />
-                </tool:annotation>
-            </xsd:appinfo>
-        </xsd:annotation>
-        <xsd:union memberTypes="xsd:string" />
-    </xsd:simpleType>
-    <!-- -->
-    <xsd:complexType name="jndiBindingType">
-        <xsd:sequence>
-            <xsd:element name="configProperty" type="configPropertyType"
-                minOccurs="0" maxOccurs="unbounded" />
-        </xsd:sequence>
-        <xsd:attribute name="jndi-name" type="xsd:string"
-            use="required" />
-        <xsd:attribute name="type" use="required">
-            <xsd:simpleType>
-                <xsd:restriction base="xsd:string">
-                    <xsd:enumeration value="ManagedDataSource" />
-                    <xsd:enumeration value="SimpeDataSource" />
-                    <xsd:enumeration value="PooledDataSource" />
-                    <xsd:enumeration value="XaPooledDataSource" />
-                </xsd:restriction>
-            </xsd:simpleType>
-        </xsd:attribute>
-        <xsd:attribute name="blocking-timeout-seconds"
-            type="xsd:string" use="optional" />
-        <xsd:attribute name="conn-pooled-datasource-class"
-            type="xsd:string" use="optional" />
-        <xsd:attribute name="connection-url" type="xsd:string"
-            use="optional" />
-        <xsd:attribute name="idle-timeout-seconds" type="xsd:string"
-            use="optional" />
-        <xsd:attribute name="init-pool-size" type="xsd:string"
-            use="optional" />
-        <xsd:attribute name="jdbc-driver-class" type="xsd:string"
-            use="optional" />
-        <xsd:attribute name="login-timeout-seconds" type="xsd:string"
-            use="optional" />
-        <xsd:attribute name="managed-connection-factory-class"
-            type="xsd:string" use="optional" />
-        <xsd:attribute name="max-pool-size" type="xsd:string"
-            use="optional" />
-        <xsd:attribute name="password" type="xsd:string"
-            use="optional" />
-        <xsd:attribute name="user-name" type="xsd:string"
-            use="optional" />
-        <xsd:attribute name="xa-datasource-class" type="xsd:string"
-            use="optional" />
-        <xsd:attribute name="transaction-type" type="xsd:string"
-            use="optional" />
-    </xsd:complexType>
-    <!-- -->
-    <xsd:complexType name="configPropertyType">
-        <xsd:sequence>
-            <xsd:element name="configPropertyName" type="xsd:string" />
-            <xsd:element name="configPropertyType" type="xsd:string" />
-            <xsd:element name="configPropertyValue" type="xsd:string" />
-        </xsd:sequence>
-    </xsd:complexType>
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:attributeGroup>
+	<!-- -->
+	<xsd:simpleType name="gemfireTemplateRef">
+		<xsd:annotation>
+			<xsd:appinfo>
+				<tool:annotation kind="ref">
+					<tool:assignable-to type="org.springframework.data.gemfire.GemfireTemplate"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:union memberTypes="xsd:string"/>
+	</xsd:simpleType>
+	<!-- -->
+	<xsd:complexType name="jndiBindingType">
+		<xsd:sequence>
+			<xsd:element name="configProperty" type="configPropertyType" minOccurs="0" maxOccurs="unbounded"/>
+		</xsd:sequence>
+		<xsd:attribute name="jndi-name" type="xsd:string" use="required"/>
+		<xsd:attribute name="type" use="required">
+			<xsd:simpleType>
+				<xsd:restriction base="xsd:string">
+					<xsd:enumeration value="ManagedDataSource"/>
+					<xsd:enumeration value="SimpeDataSource"/>
+					<xsd:enumeration value="PooledDataSource"/>
+					<xsd:enumeration value="XaPooledDataSource"/>
+				</xsd:restriction>
+			</xsd:simpleType>
+		</xsd:attribute>
+		<xsd:attribute name="blocking-timeout-seconds" type="xsd:string" use="optional"/>
+		<xsd:attribute name="conn-pooled-datasource-class" type="xsd:string" use="optional"/>
+		<xsd:attribute name="connection-url" type="xsd:string" use="optional"/>
+		<xsd:attribute name="idle-timeout-seconds" type="xsd:string" use="optional"/>
+		<xsd:attribute name="init-pool-size" type="xsd:string" use="optional"/>
+		<xsd:attribute name="jdbc-driver-class" type="xsd:string" use="optional"/>
+		<xsd:attribute name="login-timeout-seconds" type="xsd:string" use="optional"/>
+		<xsd:attribute name="managed-connection-factory-class" type="xsd:string" use="optional"/>
+		<xsd:attribute name="max-pool-size" type="xsd:string" use="optional"/>
+		<xsd:attribute name="password" type="xsd:string" use="optional"/>
+		<xsd:attribute name="user-name" type="xsd:string" use="optional"/>
+		<xsd:attribute name="xa-datasource-class" type="xsd:string" use="optional"/>
+		<xsd:attribute name="transaction-type" type="xsd:string" use="optional"/>
+	</xsd:complexType>
+	<!-- -->
+	<xsd:complexType name="configPropertyType">
+		<xsd:sequence>
+			<xsd:element name="configPropertyName" type="xsd:string"/>
+			<xsd:element name="configPropertyType" type="xsd:string"/>
+			<xsd:element name="configPropertyValue" type="xsd:string"/>
+		</xsd:sequence>
+	</xsd:complexType>
+	<!-- -->
+	<xsd:simpleType name="baseDataPolicyType">
+		<xsd:restriction base="xsd:string">
+			<xsd:enumeration value="NORMAL"/>
+			<xsd:enumeration value="EMPTY"/>
+			<xsd:enumeration value="NORMAL"/>
+			<xsd:enumeration value="PRELOADED"/>
+		</xsd:restriction>
+	</xsd:simpleType>
 </xsd:schema>
diff --git a/src/test/java/org/springframework/data/gemfire/config/DiskStoreNamespaceTest.java b/src/test/java/org/springframework/data/gemfire/config/DiskStoreNamespaceTest.java
new file mode 100644
index 00000000..dff269dc
--- /dev/null
+++ b/src/test/java/org/springframework/data/gemfire/config/DiskStoreNamespaceTest.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright 2010-2012 the original author or authors.
+ *
+ * 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.
+ */
+package org.springframework.data.gemfire.config;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.File;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.gemstone.gemfire.cache.DiskStore;
+import com.gemstone.gemfire.cache.DiskStoreFactory;
+
+/**
+ * @author David Turanski
+ * 
+ */
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration("diskstore-ns-new.xml")
+public class DiskStoreNamespaceTest {
+	private static File diskStoreDir;
+
+	@Autowired
+	DiskStore diskStore1;
+
+	@Test
+	public void testDiskStore() {
+		assertEquals("diskStore1", diskStore1.getName());
+		assertEquals(50, diskStore1.getQueueSize());
+		assertEquals(true, diskStore1.getAutoCompact());
+		assertEquals(DiskStoreFactory.DEFAULT_COMPACTION_THRESHOLD, diskStore1.getCompactionThreshold());
+		assertEquals(9999, diskStore1.getTimeInterval());
+		assertEquals(10, diskStore1.getMaxOplogSize());
+		assertEquals(diskStoreDir, diskStore1.getDiskDirs()[0]);
+	}
+
+	@BeforeClass
+	public static void setUp() {
+		String path = "./build/tmp";
+		diskStoreDir = new File(path);
+		if (!diskStoreDir.exists()) {
+			diskStoreDir.mkdir();
+		}
+	}
+
+	@AfterClass
+	public static void tearDown() {
+		for (File file : diskStoreDir.listFiles()) {
+			file.delete();
+		}
+		diskStoreDir.delete();
+	}
+}
diff --git a/src/test/java/org/springframework/data/gemfire/config/LocalRegionNamespaceTest.java b/src/test/java/org/springframework/data/gemfire/config/LocalRegionNamespaceTest.java
new file mode 100644
index 00000000..3d93d42f
--- /dev/null
+++ b/src/test/java/org/springframework/data/gemfire/config/LocalRegionNamespaceTest.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright 2010-2012 the original author or authors.
+ *
+ * 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.
+ */
+
+package org.springframework.data.gemfire.config;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.ApplicationContext;
+import org.springframework.data.gemfire.RegionFactoryBean;
+import org.springframework.data.gemfire.RegionLookupFactoryBean;
+import org.springframework.data.gemfire.TestUtils;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.util.ObjectUtils;
+
+import com.gemstone.gemfire.cache.Cache;
+import com.gemstone.gemfire.cache.CacheListener;
+import com.gemstone.gemfire.cache.DataPolicy;
+import com.gemstone.gemfire.cache.Region;
+import com.gemstone.gemfire.cache.RegionAttributes;
+import com.gemstone.gemfire.cache.Scope;
+
+/**
+ * @author Costin Leau
+ */
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration("local-ns.xml")
+public class LocalRegionNamespaceTest {
+
+	@Autowired
+	private ApplicationContext context;
+
+	@Test
+	public void testBasicReplica() throws Exception {
+		assertTrue(context.containsBean("simple"));
+	}
+
+	@Test
+	public void testPublishingReplica() throws Exception {
+		assertTrue(context.containsBean("pub"));
+		RegionFactoryBean fb = context.getBean("&pub", RegionFactoryBean.class);
+		assertEquals(DataPolicy.NORMAL, TestUtils.readField("dataPolicy", fb));
+		assertEquals(Scope.LOCAL, TestUtils.readField("scope", fb));
+		assertEquals("publisher", TestUtils.readField("name", fb));
+		RegionAttributes attrs = TestUtils.readField("attributes", fb);
+		assertFalse(attrs.getPublisher());
+	}
+
+	@Test
+	public void testComplexReplica() throws Exception {
+		assertTrue(context.containsBean("complex"));
+		RegionFactoryBean fb = context.getBean("&complex", RegionFactoryBean.class);
+		CacheListener[] listeners = TestUtils.readField("cacheListeners", fb);
+		assertFalse(ObjectUtils.isEmpty(listeners));
+		assertEquals(2, listeners.length);
+		assertSame(listeners[0], context.getBean("c-listener"));
+
+		assertSame(context.getBean("c-loader"), TestUtils.readField("cacheLoader", fb));
+		assertSame(context.getBean("c-writer"), TestUtils.readField("cacheWriter", fb));
+	}
+
+	@Test
+	public void testRegionLookup() throws Exception {
+		Cache cache = context.getBean(Cache.class);
+		Region existing = cache.createRegionFactory().create("existing");
+		assertTrue(context.containsBean("lookup"));
+		RegionLookupFactoryBean lfb = context.getBean("&lookup", RegionLookupFactoryBean.class);
+		assertEquals("existing", TestUtils.readField("name", lfb));
+		assertEquals(existing, context.getBean("lookup"));
+	}
+}
\ No newline at end of file
diff --git a/src/test/resources/org/springframework/data/gemfire/config/client-ns.xml b/src/test/resources/org/springframework/data/gemfire/config/client-ns.xml
index f2a229e8..bce2ec77 100644
--- a/src/test/resources/org/springframework/data/gemfire/config/client-ns.xml
+++ b/src/test/resources/org/springframework/data/gemfire/config/client-ns.xml
@@ -33,13 +33,13 @@
 	</gfe:pool>
 
 	<gfe:client-region id="persistent" pool-name="gemfire-pool" persistent="true">
-		<gfe:disk-store queue-size="50" auto-compact="true" max-oplog-size="10" synchronous-write="false" time-interval="9999">
+		<gfe:disk-store queue-size="50" auto-compact="true" max-oplog-size="10" time-interval="9999">
 			<gfe:disk-dir location="./" max-size="1"/>
 		</gfe:disk-store>
 	</gfe:client-region>
 	
 	<gfe:client-region id="overflow" pool-name="gemfire-pool">
-		<gfe:disk-store queue-size="50" auto-compact="true" max-oplog-size="10" synchronous-write="false" time-interval="9999">
+		<gfe:disk-store queue-size="50" auto-compact="true" max-oplog-size="10" time-interval="9999">
 			<gfe:disk-dir location="./" max-size="1"/>
 		</gfe:disk-store>
 
diff --git a/src/test/resources/org/springframework/data/gemfire/config/diskstore-ns-new.xml b/src/test/resources/org/springframework/data/gemfire/config/diskstore-ns-new.xml
new file mode 100644
index 00000000..0ce704d0
--- /dev/null
+++ b/src/test/resources/org/springframework/data/gemfire/config/diskstore-ns-new.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xmlns:gfe="http://www.springframework.org/schema/gemfire"
+    xmlns:p="http://www.springframework.org/schema/p"
+    xmlns:context="http://www.springframework.org/schema/context"
+    xmlns:util="http://www.springframework.org/schema/util"
+    xsi:schemaLocation="http://www.springframework.org/schema/gemfire http://www.springframework.org/schema/gemfire/spring-gemfire.xsd
+		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
+		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd
+		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
+
+	<gfe:cache/>
+    <util:properties id="props">
+        <prop key="location">./build/tmp</prop>
+        <prop key="queueSize">50</prop>
+        <prop key="autoCompact">true</prop>
+        <prop key="maxOpLogSize">10</prop>
+        <prop key="timeInterval">9999</prop>
+        <prop key="maxSize">1</prop>
+    </util:properties>
+    
+    <context:property-placeholder properties-ref="props"/>
+
+	<gfe:disk-store id="diskStore1" queue-size="${queueSize}" auto-compact="${autoCompact}" 
+        max-oplog-size="${maxOpLogSize}" time-interval="${timeInterval}">
+		<gfe:disk-dir location="${location}" max-size="${maxSize}"/>
+	</gfe:disk-store>
+</beans>
\ No newline at end of file
diff --git a/src/test/resources/org/springframework/data/gemfire/config/diskstore-ns.xml b/src/test/resources/org/springframework/data/gemfire/config/diskstore-ns.xml
index a91f7f85..ba11cf0c 100644
--- a/src/test/resources/org/springframework/data/gemfire/config/diskstore-ns.xml
+++ b/src/test/resources/org/springframework/data/gemfire/config/diskstore-ns.xml
@@ -24,7 +24,7 @@
     </gfe:partitioned-region>
 	
 	<gfe:replicated-region id="replicated-data" persistent="true" close="true" destroy="false">
-		<gfe:disk-store queue-size="50" auto-compact="true" max-oplog-size="10" synchronous-write="false" time-interval="9999">
+		<gfe:disk-store queue-size="50" auto-compact="true" max-oplog-size="10" time-interval="9999">
 			<gfe:disk-dir location="./build/tmp" max-size="1"/>
 		</gfe:disk-store>
 
@@ -39,7 +39,7 @@
  	
  	
 	<gfe:partitioned-region id="partition-data" persistent="false">
-		<gfe:disk-store queue-size="50" auto-compact="true" max-oplog-size="10" synchronous-write="false" time-interval="9999">
+		<gfe:disk-store queue-size="50" auto-compact="true" max-oplog-size="10" time-interval="9999">
 			<gfe:disk-dir location="./" max-size="1"/>
 		</gfe:disk-store> 
 
diff --git a/src/test/resources/org/springframework/data/gemfire/config/local-ns.xml b/src/test/resources/org/springframework/data/gemfire/config/local-ns.xml
new file mode 100644
index 00000000..7fc7f302
--- /dev/null
+++ b/src/test/resources/org/springframework/data/gemfire/config/local-ns.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xmlns:gfe="http://www.springframework.org/schema/gemfire"
+	xmlns:p="http://www.springframework.org/schema/p"
+	xmlns:util="http://www.springframework.org/schema/util"
+	xsi:schemaLocation="http://www.springframework.org/schema/gemfire http://www.springframework.org/schema/gemfire/spring-gemfire.xsd
+		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
+		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd" default-lazy-init="true">
+
+	<gfe:cache />
+	
+	<gfe:local-region id="simple" />
+	
+	<gfe:local-region id="pub" name="publisher"/>
+	
+	<gfe:local-region id="complex" close="true" destroy="false">
+		<gfe:cache-listener>
+			<ref bean="c-listener"/>
+			<bean class="org.springframework.data.gemfire.SimpleCacheListener"/>
+		</gfe:cache-listener>
+		<gfe:cache-loader ref="c-loader"/>
+		<gfe:cache-writer ref="c-writer"/>
+	</gfe:local-region>
+	
+	<bean id="c-listener" class="org.springframework.data.gemfire.SimpleCacheListener"/>
+	<bean id="c-loader" class="org.springframework.data.gemfire.SimpleCacheLoader"/>
+	<bean id="c-writer" class="org.springframework.data.gemfire.SimpleCacheWriter"/>
+	
+	<gfe:lookup-region id="lookup" name="existing"/>
+</beans>
\ No newline at end of file
diff --git a/src/test/resources/org/springframework/data/gemfire/config/subregion-ns.xml b/src/test/resources/org/springframework/data/gemfire/config/subregion-ns.xml
index d8cf4560..d0803639 100644
--- a/src/test/resources/org/springframework/data/gemfire/config/subregion-ns.xml
+++ b/src/test/resources/org/springframework/data/gemfire/config/subregion-ns.xml
@@ -18,7 +18,7 @@
     
      <gfe:replicated-region id="replicatedParent">
         <gfe:lookup-region name="lookupChild">
-            <gfe:partitioned-region name="partitionedGrandchild"/>            
+            <gfe:partitioned-region name="partitionedGrandchild"/>
         </gfe:lookup-region>
     </gfe:replicated-region>