 				if (included.containsKey(key))
 					return true;
 				// if includeMissingKeyTypes and keyType is missing
-				if (includeMissingKeyTypes.value && !_includedKeyTypeMap[key.keyType] && !_excludedKeyTypeMap[key.keyType])
+				if (_includeMissingKeyTypes && !_includedKeyTypeMap[key.keyType] && !_excludedKeyTypeMap[key.keyType])
 					return true;
 				return false;
 			}

		 */
		public function containsKey(key:IQualifiedKey):Boolean
		{
			for each (var filter:IKeyFilter in filters.getObjects())
				if (!filter.containsKey(key))
					return false;
			
			if (includeMissingKeys.value || (includeMissingKeyTypes.value && !_includedKeyTypeMap[key.keyType]))
			{
				if (excluded.containsKey(key))
					return false;
				if (!includeMissingKeyTypes.value && _excludedKeyTypeMap[key.keyType])
					return false;
				return true;
			}

		public function KeyFilter()
		{
			includeMissingKeys.value = false;
			includeMissingKeyTypes.value = true;
			filters.childListCallbacks.addImmediateCallback(this, cacheValues);
		}
		
		// option to include missing keys or not
		public const includeMissingKeys:LinkableBoolean = newLinkableChild(this, LinkableBoolean, cacheValues);
		public const includeMissingKeyTypes:LinkableBoolean = newLinkableChild(this, LinkableBoolean, cacheValues);
		
		public const included:KeySet = newLinkableChild(this, KeySet, handleIncludeChange);
		public const excluded:KeySet = newLinkableChild(this, KeySet, handleExcludeChange);
		
		public const filters:ILinkableHashMap = registerLinkableChild(this, new LinkableHashMap(IKeyFilter));
		
		private var _includeMissingKeys:Boolean;
		private var _includeMissingKeyTypes:Boolean;
		private var _filters:Array;
		private function cacheValues():void
		{
			_includeMissingKeys = includeMissingKeys.value;
			_includeMissingKeyTypes = includeMissingKeyTypes.value;
			_filters = filters.getObjects();
		}

		/**
		 * This replaces the included and excluded keys in the filter with the parameters specified.
