context: //***************************************************
  //* This file was generated by tool
  //* SharpKit
  //* At: 29/08/2012 03:59:42 p.m.
  //***************************************************
  using SharpKit.JavaScript;
  namespace Ext.util
  {
      #region Inflector
      /// <inheritdocs />
      /// <summary>
      /// <p>General purpose inflector class that <see cref="Ext.util.Inflector.pluralize">pluralizes</see>, <see cref="Ext.util.Inflector.singularize">singularizes</see> and
      /// <see cref="Ext.util.Inflector.ordinalize">ordinalizes</see> words. Sample usage:</p>
      /// <pre><code>//turning singular words into plurals
      /// <see cref="Ext.util.Inflector.pluralize">Ext.util.Inflector.pluralize</see>('word'); //'words'
      /// <see cref="Ext.util.Inflector.pluralize">Ext.util.Inflector.pluralize</see>('person'); //'people'
      /// <see cref="Ext.util.Inflector.pluralize">Ext.util.Inflector.pluralize</see>('sheep'); //'sheep'
      /// //turning plurals into singulars
      /// <see cref="Ext.util.Inflector.singularize">Ext.util.Inflector.singularize</see>('words'); //'word'
      /// <see cref="Ext.util.Inflector.singularize">Ext.util.Inflector.singularize</see>('people'); //'person'
      /// <see cref="Ext.util.Inflector.singularize">Ext.util.Inflector.singularize</see>('sheep'); //'sheep'
      /// //ordinalizing numbers
      /// <see cref="Ext.util.Inflector.ordinalize">Ext.util.Inflector.ordinalize</see>(11); //"11th"
      /// <see cref="Ext.util.Inflector.ordinalize">Ext.util.Inflector.ordinalize</see>(21); //"21st"
      /// <see cref="Ext.util.Inflector.ordinalize">Ext.util.Inflector.ordinalize</see>(1043); //"1043rd"
      /// </code></pre>
      /// <h1>Customization</h1>
      /// <p>The Inflector comes with a default set of US English pluralization rules. These can be augmented with additional
      /// rules if the default rules do not meet your application's requirements, or swapped out entirely for other languages.
      /// Here is how we might add a rule that pluralizes "ox" to "oxen":</p>
      /// <pre><code><see cref="Ext.util.Inflector.plural">Ext.util.Inflector.plural</see>(/^(ox)$/i, "$1en");
      /// </code></pre>
      /// <p>Each rule consists of two items - a regular expression that matches one or more rules, and a replacement string. In
      /// this case, the regular expression will only match the string "ox", and will replace that match with "oxen". Here's
      /// how we could add the inverse rule:</p>
      /// <pre><code><see cref="Ext.util.Inflector.singular">Ext.util.Inflector.singular</see>(/^(ox)en$/i, "$1");
      /// </code></pre>
      /// <p>Note that the ox/oxen rules are present by default.</p>
      /// </summary>
      [JsType(JsMode.Prototype, Export=false, OmitOptionalParameters=true)]
      public partial class Inflector : Ext.Base
      {
          /// <summary>
          /// Defaults to: <c>&quot;Ext.Base&quot;</c>
          /// </summary>
          [JsProperty(Name="$className")]
          private static JsString @className{get;set;}
          /// <summary>
          /// Defaults to: <c>{}</c>
          /// </summary>
          private static JsObject configMap{get;set;}
          /// <summary>
          /// Defaults to: <c>[]</c>
          /// </summary>
          private static JsArray initConfigList{get;set;}
          /// <summary>
          /// Defaults to: <c>{}</c>
          /// </summary>
          private static JsObject initConfigMap{get;set;}
          /// <summary>
          /// Defaults to: <c>true</c>
          /// </summary>
          private static bool isInstance{get;set;}
          /// <summary>
          /// The registered plural tuples. Each item in the array should contain two items - the first must be a regular
          /// expression that matchers the singular form of a word, the second must be a String that replaces the matched
          /// part of the regular expression. This is managed by the plural method.
          /// </summary>
          private static JsArray plurals{get;set;}
          /// <summary>
          /// Get the reference to the current class from which this object was instantiated. Unlike statics,
          /// this.self is scope-dependent and it's meant to be used for dynamic inheritance. See statics
          /// for a detailed comparison
          /// <code><see cref="Ext.ExtContext.define">Ext.define</see>('My.Cat', {
          /// statics: {
          /// speciesName: 'Cat' // My.Cat.speciesName = 'Cat'
          /// },
          /// constructor: function() {
          /// alert(this.self.speciesName); // dependent on 'this'
          /// },
          /// clone: function() {
          /// return new this.self();
          /// }
          /// });
          /// <see cref="Ext.ExtContext.define">Ext.define</see>('My.SnowLeopard', {
          /// extend: 'My.Cat',
          /// statics: {
          /// speciesName: 'Snow Leopard'         // My.SnowLeopard.speciesName = 'Snow Leopard'
          /// }
          /// });
          /// var cat = new My.Cat();                     // alerts 'Cat'
          /// var snowLeopard = new My.SnowLeopard();     // alerts 'Snow Leopard'
          /// var clone = snowLeopard.clone();
          /// alert(<see cref="Ext.ExtContext.getClassName">Ext.getClassName</see>(clone));             // alerts 'My.SnowLeopard'
          /// </code>
          /// </summary>
          protected static Class self{get;set;}
          /// <summary>
          /// The set of registered singular matchers. Each item in the array should contain two items - the first must be a
          /// regular expression that matches the plural form of a word, the second must be a String that replaces the
          /// matched part of the regular expression. This is managed by the singular method.
          /// </summary>
          private static JsArray singulars{get;set;}
          /// <summary>
          /// The registered uncountable words
          /// Defaults to: <c>[&quot;sheep&quot;, &quot;fish&quot;, &quot;series&quot;, &quot;species&quot;, &quot;money&quot;, &quot;rice&quot;, &quot;information&quot;, &quot;equipment&quot;, &quot;grass&quot;, &quot;mud&quot;, &quot;offspring&quot;, &quot;deer&quot;, &quot;means&quot;]</c>
          /// </summary>
          private static JsString uncountable{get;set;}
          /// <summary>
          /// Call the original method that was previously overridden with override
          /// <code><see cref="Ext.ExtContext.define">Ext.define</see>('My.Cat', {
          /// constructor: function() {
          /// alert("I'm a cat!");
          /// }
          /// });
          /// My.Cat.override({
          /// constructor: function() {
          /// alert("I'm going to be a cat!");
          /// this.callOverridden();
          /// alert("Meeeeoooowwww");
          /// }
          /// });
          /// var kitty = new My.Cat(); // alerts "I'm going to be a cat!"
          /// // alerts "I'm a cat!"
          /// // alerts "Meeeeoooowwww"
          /// </code>
          /// <p>This method has been <strong>deprecated</strong> </p>
          /// <p>as of 4.1. Use <see cref="Ext.Base.callParent">callParent</see> instead.</p>
          /// </summary>
          /// <param name="args"><p>The arguments, either an array or the <c>arguments</c> object
          /// from the current method, for example: <c>this.callOverridden(arguments)</c></p>
          /// </param>
          /// <returns>
          /// <span><see cref="Object">Object</see></span><div><p>Returns the result of calling the overridden method</p>
          /// </div>
          /// </returns>
          protected static object callOverridden(object args=null){return null;}
          /// <summary>
          /// Call the "parent" method of the current method. That is the method previously
          /// overridden by derivation or by an override (see Ext.define).
          /// <code> <see cref="Ext.ExtContext.define">Ext.define</see>('My.Base', {
          /// constructor: function (x) {
          /// this.x = x;
          /// },
          /// statics: {
          /// method: function (x) {
          /// return x;
          /// }
          /// }
          /// });
          /// <see cref="Ext.ExtContext.define">Ext.define</see>('My.Derived', {
          /// extend: 'My.Base',
          /// constructor: function () {
          /// this.callParent([21]);
          /// }
          /// });
          /// var obj = new My.Derived();
          /// alert(obj.x);  // alerts 21
          /// </code>
          /// This can be used with an override as follows:
          /// <code> <see cref="Ext.ExtContext.define">Ext.define</see>('My.DerivedOverride', {
          /// override: 'My.Derived',
          /// constructor: function (x) {
          /// this.callParent([x*2]); // calls original My.Derived constructor
          /// }
          /// });
          /// var obj = new My.Derived();
          /// alert(obj.x);  // now alerts 42
          /// </code>
          /// This also works with static methods.
          /// <code> <see cref="Ext.ExtContext.define">Ext.define</see>('My.Derived2', {
          /// extend: 'My.Base',
          /// statics: {
          /// method: function (x) {
          /// return this.callParent([x*2]); // calls My.Base.method
          /// }
          /// }
          /// });
          /// alert(My.Base.method(10);     // alerts 10
          /// alert(My.Derived2.method(10); // alerts 20
          /// </code>
          /// Lastly, it also works with overridden static methods.
          /// <code> <see cref="Ext.ExtContext.define">Ext.define</see>('My.Derived2Override', {
          /// override: 'My.Derived2',
          /// statics: {
          /// method: function (x) {
          /// return this.callParent([x*2]); // calls My.Derived2.method
          /// }
          /// }
          /// });
          /// alert(My.Derived2.method(10); // now alerts 40
          /// </code>
          /// </summary>
          /// <param name="args"><p>The arguments, either an array or the <c>arguments</c> object
          /// from the current method, for example: <c>this.callParent(arguments)</c></p>
          /// </param>
          /// <returns>
          /// <span><see cref="Object">Object</see></span><div><p>Returns the result of calling the parent method</p>
          /// </div>
          /// </returns>
          protected static object callParent(object args=null){return null;}
          /// <summary>
          /// Returns the correct Model name for a given string. Mostly used internally by the data
          /// package
          /// </summary>
          /// <param name="word"><p>The word to classify</p>
          /// </param>
          /// <returns>
          /// <span><see cref="String">String</see></span><div><p>The classified version of the word</p>
          /// </div>
          /// </returns>
          public static JsString classify(JsString word){return null;}
          /// <summary>
          /// Removes all registered pluralization rules
          /// </summary>
          public static void clearPlurals(){}
          /// <summary>
          /// Removes all registered singularization rules
          /// </summary>
          public static void clearSingulars(){}
          /// <summary>
          /// </summary>
          private static void configClass(){}
          /// <summary>
          /// Overrides: <see cref="Ext.AbstractComponent.destroy">Ext.AbstractComponent.destroy</see>, <see cref="Ext.AbstractPlugin.destroy">Ext.AbstractPlugin.destroy</see>, <see cref="Ext.layout.Layout.destroy">Ext.layout.Layout.destroy</see>
          /// </summary>
          private static void destroy(){}
          /// <summary>
          /// Parameters<li><span>name</span> : <see cref="Object">Object</see><div>
          /// </div></li>
          /// </summary>
          /// <param name="name">
          /// </param>
          private static void getConfig(object name){}
          /// <summary>
          /// Returns the initial configuration passed to constructor when instantiating
          /// this class.
          /// </summary>
          /// <param name="name"><p>Name of the config option to return.</p>
          /// </param>
          /// <returns>
          /// <span><see cref="Object">Object</see>/Mixed</span><div><p>The full config object or a single config value
          /// when <c>name</c> parameter specified.</p>
          /// </div>
          /// </returns>
          public static object getInitialConfig(object name=null){return null;}
          /// <summary>
          /// Parameters<li><span>config</span> : <see cref="Object">Object</see><div>
          /// </div></li>
          /// </summary>
          /// <param name="config">
          /// </param>
          private static void hasConfig(object config){}
          /// <summary>
          /// Initialize configuration for this class. a typical example:
          /// <code><see cref="Ext.ExtContext.define">Ext.define</see>('My.awesome.Class', {
          /// // The default config
          /// config: {
          /// name: 'Awesome',
          /// isAwesome: true
          /// },
          /// constructor: function(config) {
          /// this.initConfig(config);
          /// }
          /// });
          /// var awesome = new My.awesome.Class({
          /// name: 'Super Awesome'
          /// });
          /// alert(awesome.getName()); // 'Super Awesome'
          /// </code>
          /// </summary>
          /// <param name="config">
          /// </param>
          /// <returns>
          /// <span><see cref="Ext.Base">Ext.Base</see></span><div><p>this</p>
          /// </div>
          /// </returns>
          protected static Ext.Base initConfig(object config){return null;}
          /// <summary>
          /// Returns true if the given word is transnumeral (the word is its own singular and plural form - e.g. sheep, fish)
          /// </summary>
          /// <param name="word"><p>The word to test</p>
          /// </param>
          /// <returns>
          /// <span><see cref="bool">Boolean</see></span><div><p>True if the word is transnumeral</p>
          /// </div>
          /// </returns>
          public static bool isTransnumeral(JsString word){return false;}
          /// <summary>
          /// Parameters<li><span>names</span> : <see cref="Object">Object</see><div>
          /// </div></li><li><span>callback</span> : <see cref="Object">Object</see><div>
          /// </div></li><li><span>scope</span> : <see cref="Object">Object</see><div>
          /// </div></li>
          /// </summary>
          /// <param name="names">
          /// </param>
          /// <param name="callback">
          /// </param>
          /// <param name="scope">
          /// </param>
          private static void onConfigUpdate(object names, object callback, object scope){}
          /// <summary>
          /// Ordinalizes a given number by adding a prefix such as 'st', 'nd', 'rd' or 'th' based on the last digit of the
          /// number. 21 -> 21st, 22 -> 22nd, 23 -> 23rd, 24 -> 24th etc
          /// </summary>
          /// <param name="number"><p>The number to ordinalize</p>
          /// </param>
          /// <returns>
          /// <span><see cref="String">String</see></span><div><p>The ordinalized number</p>
          /// </div>
          /// </returns>
          public static JsString ordinalize(JsNumber number){return null;}
          /// <summary>
          /// Adds a new pluralization rule to the Inflector. See the intro docs for more information
          /// </summary>
          /// <param name="matcher"><p>The matcher regex</p>
          /// </param>
          /// <param name="replacer"><p>The replacement string, which can reference matches from the matcher argument</p>
          /// </param>
          public static void plural(JsRegExp matcher, JsString replacer){}
          /// <summary>
          /// Returns the pluralized form of a word (e.g. Ext.util.Inflector.pluralize('word') returns 'words')
          /// </summary>
          /// <param name="word"><p>The word to pluralize</p>
          /// </param>
          /// <returns>
          /// <span><see cref="String">String</see></span><div><p>The pluralized form of the word</p>
          /// </div>
          /// </returns>
          public static JsString pluralize(JsString word){return null;}
          /// <summary>
          /// Parameters<li><span>config</span> : <see cref="Object">Object</see><div>
          /// </div></li><li><span>applyIfNotSet</span> : <see cref="Object">Object</see><div>
          /// </div></li>
          /// </summary>
          /// <param name="config">
          /// </param>
          /// <param name="applyIfNotSet">
          /// </param>
          private static void setConfig(object config, object applyIfNotSet){}
          /// <summary>
          /// Adds a new singularization rule to the Inflector. See the intro docs for more information
          /// </summary>
          /// <param name="matcher"><p>The matcher regex</p>
          /// </param>
          /// <param name="replacer"><p>The replacement string, which can reference matches from the matcher argument</p>
          /// </param>
          public static void singular(JsRegExp matcher, JsString replacer){}
          /// <summary>
          /// Returns the singularized form of a word (e.g. Ext.util.Inflector.singularize('words') returns 'word')
          /// </summary>
          /// <param name="word"><p>The word to singularize</p>
          /// </param>
          /// <returns>
          /// <span><see cref="String">String</see></span><div><p>The singularized form of the word</p>
          /// </div>
          /// </returns>
          public static JsString singularize(JsString word){return null;}
          /// <summary>
          /// Get the reference to the class from which this object was instantiated. Note that unlike self,
          /// this.statics() is scope-independent and it always returns the class from which it was called, regardless of what
          /// this points to during run-time
          /// <code><see cref="Ext.ExtContext.define">Ext.define</see>('My.Cat', {
          /// statics: {
          /// totalCreated: 0,
          /// speciesName: 'Cat' // My.Cat.speciesName = 'Cat'
          /// },
          /// constructor: function() {
          /// var statics = this.statics();
          /// alert(statics.speciesName);     // always equals to 'Cat' no matter what 'this' refers to
          /// // equivalent to: My.Cat.speciesName
          /// alert(this.self.speciesName);   // dependent on 'this'
          /// statics.totalCreated++;
          /// },
          /// clone: function() {
          /// var cloned = new this.self;                      // dependent on 'this'
          /// cloned.groupName = this.statics().speciesName;   // equivalent to: My.Cat.speciesName
          /// return cloned;
          /// }
          /// });
          /// <see cref="Ext.ExtContext.define">Ext.define</see>('My.SnowLeopard', {
          /// extend: 'My.Cat',
          /// statics: {
          /// speciesName: 'Snow Leopard'     // My.SnowLeopard.speciesName = 'Snow Leopard'
          /// },
          /// constructor: function() {
          /// this.callParent();
          /// }
          /// });
          /// var cat = new My.Cat();                 // alerts 'Cat', then alerts 'Cat'
          /// var snowLeopard = new My.SnowLeopard(); // alerts 'Cat', then alerts 'Snow Leopard'
          /// var clone = snowLeopard.clone();
          /// alert(<see cref="Ext.ExtContext.getClassName">Ext.getClassName</see>(clone));         // alerts 'My.SnowLeopard'
          /// alert(clone.groupName);                 // alerts 'Cat'
          /// alert(My.Cat.totalCreated);             // alerts 3
          /// </code>
          /// </summary>
          /// <returns>
          /// <span><see cref="Ext.Class">Ext.Class</see></span><div>
          /// </div>
          /// </returns>
          protected static Class statics(){return null;}
          public Inflector(InflectorConfig config){}
          public Inflector(){}
          public Inflector(params object[] args){}
      }
      #endregion
      #region InflectorConfig
      /// <inheritdocs />
      [JsType(JsMode.Json, Export=false, OmitOptionalParameters=true)]
      public partial class InflectorConfig : Ext.BaseConfig
      {
          public InflectorConfig(params object[] args){}
      }
      #endregion
      #region InflectorEvents
      /// <inheritdocs />
  
gt:     [JsType(JsMode.Json, Export=false, OmitOptionalParameters=true)]