public virtual Element AnchorTo(Element element, string position, int[] offsets, ElementFxConfig animate, bool monitorScroll, JFunction callback)
 {
     this.Call("anchorTo", new JRawValue(element.Descriptor), position, offsets, new JRawValue(new ClientConfig().Serialize(animate, true)), monitorScroll, callback);
     return this;
 }

 public virtual Element ReplaceWith(Element element)
 {
     this.Call("replaceWith", new JRawValue(element.Descriptor));
     return this;
 }

 public virtual void Mon(Element el, string eventName, string fn, string scope, HandlerConfig options)
 {
     this.Call("mon", new JRawValue(el.Descriptor), eventName, fn, new JRawValue(scope), new JRawValue(options.Serialize()));
 }

 /// <summary>
 /// Visually highlights an event using Ext.Fx.highlight config options. If highlightEventActions is false this method will have no effect.
 /// </summary>
 /// <param name="el">The element(s) to highlight</param>
 /// <param name="color">(optional) The highlight color. Should be a 6 char hex color without the leading # (defaults to yellow: 'ffff9c')</param>
 /// <param name="o">(optional) Object literal with any of the Ext.Fx config options. See Ext.Fx.highlight for usage examples.</param>
 public void HighlightEvent(Element el, string color, HighlightConfig o)
 {
     this.Call("highlightEvent", new JRawValue(el.Descriptor), color, new JRawValue(new ClientConfig().Serialize(o)));
 }

 public void InsertFirst(Element target, object data)
 {
     this.Call("insertFirst", new JRawValue(target.Descriptor), data);
 }

 public Dom(Element element)
 {
     this.element = element;            
 }

 public virtual Element Center(Element centerIn)
 {
     this.Call("center", new JRawValue(centerIn.Descriptor));
     return this;
 }

        public virtual Element Add(Element[] elements)
        {
            this.EnsureChaining();

            StringBuilder sb = new StringBuilder();
            sb.Append("[");
            foreach (Element element in elements)
            {
                sb.Append(element.Descriptor).Append(",");
            }
            sb.Remove(sb.Length-1,1).Append("]");

            this.Call("add", new JRawValue(sb.ToString()));
            return this;
        }

 public virtual Element AppendTo(Element element)
 {
     this.Call("appendTo", new JRawValue(element.Descriptor));
     return this;
 }

 public virtual Element ScrollIntoView(Element container)
 {
     this.Call("scrollIntoView", new JRawValue(container.Descriptor));
     return this;
 }

 public virtual Element CreateChild(DomObject config, Element insertBefore)
 {
     this.Call("createChild", new JRawValue(config.Serialize()), new JRawValue(insertBefore.Descriptor + ".dom"));
     return this;
 }

 public virtual Element Up(string selector, Element maxDepth)
 {
     this.EnsureChaining();
     this.Call("up", selector, new JRawValue(maxDepth.Descriptor));
     return this;
 }

 public virtual Element CreateProxy(DomObject config, Element renderTo, bool matchBox)
 {
     this.Call("createProxy", new JRawValue(config.Serialize()), new JRawValue(renderTo.Descriptor+".dom"), matchBox);
     return this;
 }

 public void Append(Element target, object data)
 {
     this.Call("append", new JRawValue(target.Descriptor), data);
 }

 public void Overwrite(Element target, object data)
 {
     this.Call("overwrite", new JRawValue(target.Descriptor), data);
 }

 public virtual Element FindParentNode(string selector, Element maxDepth)
 {
     this.EnsureChaining();
     this.Call("findParentNode", selector, new JRawValue(maxDepth.Descriptor + ".dom"), true);
     return this;
 }

 public virtual Element InsertSibling(Element element, InsertPosition where)
 {
     this.Call("insertSibling", new JRawValue(element.Descriptor), where.ToString().ToLowerCamelCase());
     return this;
 }

 public virtual void Mun(Element el, string eventName, string fn, string scope)
 {
     this.Call("mun", new JRawValue(el.Descriptor), eventName, new JRawValue(fn), new JRawValue(scope));
 }

 /// <summary>
 /// Init element of tracker
 /// </summary>
 /// <param name="el">Element</param>
 public void InitElement(Element el)
 {
     this.Call("initEl", new JRawValue(el.Descriptor));
 }

 public virtual Element AlignTo(Element element, string position, int[] offsets)
 {
     this.Call("alignTo", new JRawValue(element.Descriptor), position, offsets);
     return this;
 }