package common
{
	import flash.utils.Dictionary;

	public class Enumeration
	{
		private var type:String;
		private var name:String;

		private static var initialized:Dictionary = new Dictionary();

		private static var inOrder:Dictionary = new Dictionary();

		private static var byName:Dictionary = new Dictionary();

		public function Enumeration(type:String, name:String)
		{
			if (initialized[type] != null) {
				throw new Error(type + " is an enumeration.  New is not allowed.");
			}

			this.type = type;
			this.name = name;

			storeInOrder();

			storeByName();
		}

		private function storeByName():void {
			if (byName[ this.type ] == null) {
				byName[ this.type ] = new Dictionary();
			}

			byName[ this.type ][ this.name ] = this;
		}

		private function storeInOrder():void {
			if (inOrder[ this.type ] == null) {
				inOrder[ this.type ] = new Array();
			}

			inOrder[ this.type ].push(this);
		}

		public function toString():String {
			return this.name;
		}

		protected static function getAll(type:String):Array {
			if (! initialized[type]) {
				throw new(type + " not initialized yet!");
			}

			return inOrder[ type ].concat();   // copy so no one can mess it up
		}

		protected static function fromString(type:String, name:String):Enumeration {
			if (! initialized[type]) {
				throw new(type + " not initialized yet!");
			}

			if (byName[ type ][ name ] == null) {
				throw new Error(type + " name unrecognized: " + name);
			}

			return byName[ type ][ name ];
		}

		protected static function initialize(type:String):void {
			initialized[type] = true;
		}
	}
}

Here's some code to test it…

package suite.cases.common
{

	import flash.errors.IllegalOperationError;

	import org.flexunit.Assert;
	import org.flexunit.assertThat;

	public class EnumerationTest
	{
		[BeforeClass]
		public static function runBeforeClass():void {
			// run for one time before all test cases
		}   

		[AfterClass]
		public static function runAfterClass():void {
			// run for one time after all test cases
		}   

		[Before(order=1)]
		public function runBeforeEveryTest():void {
			// run before every test
		}

		[After]
		public function runAfterEveryTest():void {
			// run after every test
		} 		

		[Test]
		public function testToString():void {
			Assert.assertEquals("Apple", Fruit.APPLE.toString());
			Assert.assertEquals("Banana", Fruit.BANANA.toString());
			Assert.assertEquals("Orange", Fruit.ORANGE.toString());
		}

		[Test]
		public function testFromString():void {
			Assert.assertEquals(Fruit.APPLE, Fruit.fromString("Apple"));
			Assert.assertEquals(Fruit.BANANA, Fruit.fromString("Banana"));
			Assert.assertEquals(Fruit.ORANGE, Fruit.fromString("Orange"));
		}

		[Test]
		public function testGetAll():void {
			Assert.assertEquals(
				[ Fruit.APPLE, Fruit.BANANA, Fruit.ORANGE ].toString(),
				Fruit.getAll().toString());
		}

		[Test(expects="Error")]
		public function anotherFruit():void {
			new Fruit("PLUM");
		}
	}
}

import common.Enumeration;

class Fruit extends Enumeration {

	private static const FRUIT:String = "Fruit";

	public static const APPLE:Fruit = new Fruit("Apple");
	public static const BANANA:Fruit = new Fruit("Banana");
	public static const ORANGE:Fruit = new Fruit("Orange");

	Enumeration.initialize(FRUIT);		

	public function Fruit(name:String) {
		super(FRUIT, name);
	}

	public static function getAll():Array {
		return Enumeration.getAll(FRUIT);
	}

	public static function fromString(name:String):Fruit {
		return Enumeration.fromString(FRUIT, name) as Fruit;
	}
}

I've struggled with static initializers for a while, the way you've done it'll not allow you to run other code (such as "for", "if", etc.) than allocations.
The way I found to solve this was through anonymous function:

(function() {
…
})();

LZ

It's still not a "real" singleton, it's just a class with another type of magic to prevent uncontrolled instantiation. Until AS3 supports private constructors, you can't have a real singleton, only "close enough" approximations through one of several approaches.

package
{
  public class Singleton
  {
    private static var INSTANCE:Singleton;

    public static function getInstance():Singleton
    {
       if(!INSTANCE) INSTANCE = new Singleton(new SingletonKey());
       return INSTANCE;
    }

    public function Singleton(key:SingletonKey = null)
    {
      if(!key) throw new Error("Singleton class");
    }
  }
}
internal class SingletonKey {}

public class Foo {
private static const MAGIC_NUM:Number = Math.random();
private static const INSTANCE:Foo = new Foo(MAGIC_NUM);

public function Foo(_magicNum) {
if (_magicNum != MAGIC_NUM)
throw new Error("Singleton, dummy!");
}

public function getInstance():Foo
{
return INSTANCE;
}
}

package {
	final public class ColorEnum  {
		//STATIC
		public static const BLACK:ColorEnum = new ColorEnum(0x000000,null);
		public static const WHITE:ColorEnum = new ColorEnum(0xFFFFFF,null);

		//INSTANCE
		private var _color:uint

		public function get color():uint  {
			return _color
		}

		function ColorEnum(color:uint,block_:block_constructor)  {
			if (ColorEnum) throw new Error("You can't instantiate ColorEnum");
			_color = color;
		}
	}
}

class block_constructor {}