While I don't recommend it as standard practice, there have been a few cases where I have found it useful to use a set of static (class level) methods to proxy a singleton implementation. This simplifies access so that you can do this: 
MyClass.myMethod(param);
instead of this: 
MyClass.getInstance().myMethod(param);
This can be achieved relatively simply, while maintaining the advantages of Singleton, by exposing static methods that pass requests on to instance methods via a standard getInstance call: 
class com.gskinner.demos.StaticInterfaceDemo {
   
 // private class members:
   private static var instance:StaticInterfaceDemo;
   private static function getInstance():StaticInterfaceDemo {
      if (instance == undefined) { instance = new StaticInterfaceDemo(); }
      return instance;
    }
   
 // static "proxy" interface:
   public static function myMethod(p_param:Number):Number {
      return getInstance().iMyMethod(p_param);
    }
   
 // constructor:
   private function StaticInterfaceDemo() {
      evtDispatcher = {};
      EventDispatcher.initialize(evtDispatcher);
    }
   
 // instance methods:
   // we'll use an "i" prefix to differentiate instance methods
   // that are proxied by a static method. Plus, iAnything is cool!
   private function iMyMethod(p_param:Number):Number {
      return p_param * 2;
    }
}
Where this gets a little tricky is if you want the class to act as an event dispatcher. The class needs to expose addEventListener and removeEventListener as static methods, but if you use EventDispatcher.initialize(this) in the constructor, it will try to set up those methods on the instance. This will cause problems, because in Flash, you can't have class and instance level methods with the same name. Instead, you can set up a generic object to act as an event dispatcher, and redirect all the event logic to it.

Because it should look like the events are being sent from the class, not the generic object, you'll also want to intercept dispatchEvent calls and set the target. The result looks something like this: 
import mx.events.EventDispatcher;

class com.gskinner.demos.StaticInterfaceDemo {
   
 // private class members:
   private static var instance:StaticInterfaceDemo;
   private static function getInstance():StaticInterfaceDemo {
      if (instance == undefined) { instance = new StaticInterfaceDemo(); }
      return instance;
    }
   
 // static "proxy" interface:
   public static function myMethod(p_param:Number):Number {
      return getInstance().iMyMethod(p_param);
    }
   //event dispatcher:
   public static function addEventListener(p_type:String,p_obj:Object):Void {
      getInstance().evtDispatcher.addEventListener(p_type,p_obj);
    }
   public static function removeEventListener(p_type:String,p_obj:Object):Void {
      getInstance().evtDispatcher.removeEventListener(p_type,p_obj);
    }
   
 // instance properties:
   private var evtDispatcher:Object;
   
 // constructor:
   private function StaticInterfaceDemo() {
      evtDispatcher = {};
      EventDispatcher.initialize(evtDispatcher);
    }
   
 // instance methods:
   // we'll use an "i" prefix to differentiate instance methods
   // that are proxied by a static method. Plus, iAnything is cool!
   private function iMyMethod(p_param:Number):Number {
      // just to demonstrate this:
      dispatchEvent({type:"testEvent"});
      return p_param * 2;
    }
   
   private function dispatchEvent(p_evtObj:Object):Void {
      // set the target to the class, and then route it through
      // the evtDispatcher object:
      p_evtObj.target = StaticInterfaceDemo;
      evtDispatcher.dispatchEvent(p_evtObj);
    }
}
You get the shared data and global access benefits of Singleton, with the ease of use of an instance. It looks like this in use: 
import com.gskinner.demos.StaticInterfaceDemo;
StaticInterfaceDemo.addEventListener("testEvent",this);

trace("result: "+StaticInterfaceDemo.myMethod(4));
// traces "result: 8"

function testEvent(p_evtObj:Object):Void {
   trace("target is SID? "+(p_evtObj.target == StaticInterfaceDemo));
   // traces "target is SID? true"
}
You can download the above code by clicking here.

If memory serves, this will translate even better in AS3, because you can finally instantiate EventDispatcher directly.

Questions?