/**
                             * @module node
                             * @submodule node-base
                             */
                            
                            var methods = [
                            /**
                             * Determines whether the node has the given className.
                             * @method hasClass
                             * @for Node
                             * @param {String} className the class name to search for
                             * @return {Boolean} Whether or not the node has the specified class
                             */
                             'hasClass',
                            
                            /**
                             * Adds a class name to the node.
                             * @method addClass
                             * @param {String} className the class name to add to the node's class attribute
                             * @chainable
                             */
                             'addClass',
                            
                            /**
                             * Removes a class name from the node.
                             * @method removeClass
                             * @param {String} className the class name to remove from the node's class attribute
                             * @chainable
                             */
                             'removeClass',
                            
                            /**
                             * Replace a class with another class on the node.
                             * If no oldClassName is present, the newClassName is simply added.
                             * @method replaceClass
                             * @param {String} oldClassName the class name to be replaced
                             * @param {String} newClassName the class name that will be replacing the old class name
                             * @chainable
                             */
                             'replaceClass',
                            
                            /**
                             * If the className exists on the node it is removed, if it doesn't exist it is added.
                             * @method toggleClass
                             * @param {String} className the class name to be toggled
                             * @param {Boolean} force Option to force adding or removing the class.
                             * @chainable
                             */
                             'toggleClass'
                            ];
                            
                            Y.Node.importMethod(Y.DOM, methods);
                            /**
                             * Determines whether each node has the given className.
                             * @method hasClass
                             * @see Node.hasClass
                             * @for NodeList
                             * @param {String} className the class name to search for
                             * @return {Array} An array of booleans for each node bound to the NodeList.
                             */
                            
                            /**
                             * Adds a class name to each node.
                             * @method addClass
                             * @see Node.addClass
                             * @param {String} className the class name to add to each node's class attribute
                             * @chainable
                             */
                            
                            /**
                             * Removes a class name from each node.
                             * @method removeClass
                             * @see Node.removeClass
                             * @param {String} className the class name to remove from each node's class attribute
                             * @chainable
                             */
                            
                            /**
                             * Replace a class with another class for each node.
                             * If no oldClassName is present, the newClassName is simply added.
                             * @method replaceClass
                             * @see Node.replaceClass
                             * @param {String} oldClassName the class name to be replaced
                             * @param {String} newClassName the class name that will be replacing the old class name
                             * @chainable
                             */
                            
                            /**
                             * For each node, if the className exists on the node it is removed, if it doesn't exist it is added.
                             * @method toggleClass
                             * @see Node.toggleClass
                             * @param {String} className the class name to be toggled
                             * @chainable
                             */
                            Y.NodeList.importMethod(Y.Node.prototype, methods);