    /**
     * @private
     */
    Ext.define('Ext.Evented', {

        alternateClassName: 'Ext.EventedBase',

        mixins: ['Ext.mixin.Observable'],

        statics: {
            generateSetter: function(nameMap) {
                var internalName = nameMap.internal,
                    applyName = nameMap.apply,
                    changeEventName = nameMap.changeEvent,
                    doSetName = nameMap.doSet;

                return function(value) {
                    var initialized = this.initialized,
                        oldValue = this[internalName],
                        applier = this[applyName];

                    if (applier) {
                        value = applier.call(this, value, oldValue);

                        if (typeof value == 'undefined') {
                            return this;
                        }
                    }

                    if (value !== oldValue) {
                        if (initialized) {
                            this.fireAction(changeEventName, [this, value, oldValue], this.doSet, this, {
                                nameMap: nameMap
                            });
                        }
                        else {
                            this[internalName] = value;
                            this[doSetName].call(this, value, oldValue);
                        }
                    }

                    return this;
                }
            }
        },

        initialized: false,

        constructor: function(config) {
            this.initialConfig = config;
            this.initialize();
        },

        initialize: function() {
            this.initConfig(this.initialConfig);
            this.initialized = true;
        },

        doSet: function(me, value, oldValue, options) {
            var nameMap = options.nameMap;

            me[nameMap.internal] = value;
            me[nameMap.doSet].call(this, value, oldValue);
        },

        onClassExtended: function(Class, data) {
            if (!data.hasOwnProperty('eventedConfig')) {
                return;
            }

            var ExtClass = Ext.Class,
                config = data.config,
                eventedConfig = data.eventedConfig,
                name, nameMap;

            data.config = (config) ? Ext.applyIf(config, eventedConfig) : eventedConfig;

            /*
             * These are generated setters for eventedConfig
             *
             * If the component is initialized, it invokes fireAction to fire the event as well,
             * which indicate something has changed. Otherwise, it just executes the action
             * (happens during initialization)
             *
             * This is helpful when we only want the event to be fired for subsequent changes.
             * Also it's a major performance improvement for instantiation when fired events
             * are mostly useless since there's no listeners
             */
            for (name in eventedConfig) {
                if (eventedConfig.hasOwnProperty(name)) {
                    nameMap = ExtClass.getConfigNameMap(name);

                    data[nameMap.set] = this.generateSetter(nameMap);
                }
            }
        }
    });