typescript-closure-tools/lib/definitely-typed/appframework/appframework.d.ts

Command-line tools to convert closure-style JSDoc annotations to typescript, and to convert typescript sources to closure externs files

// Type definitions for AppFramework 2.0
// Project: http://app-framework-software.intel.com/
// Definitions by: kyo_ago <https://github.com/kyo-ago>
// Definitions: https://github.com/borisyankov/DefinitelyTyped

interface appFrameworkStatic {
    /**
     * This is the internal appframework object that gets extended and added on to it
     * This is also the start of our query selector engine
     * @param {String|Element|Object|Array} selector
     * @param {String|Element|Object} [context]
     */
    (selector: string, context?: any): appFrameworkCollection;
    (collection: appFrameworkCollection): appFrameworkCollection;
    (element: HTMLElement): appFrameworkCollection;
    (htmlString: string): appFrameworkCollection;
    (object: any): appFrameworkCollection;

    /**
     * Checks to see if the parameter is a $afm object
     ```
     var foo=$('#header');
     $.is$(foo);
     ```

     * @param {Object} element
     * @return {Boolean}
     * @title $.is$(param)
     */
    is$(obj: any): boolean;

    /**
     * Map takes in elements and executes a callback function on each and returns a collection
     ```
     $.map([1,2],function(ind){return ind+1});
     ```

     * @param {Array|Object} elements
     * @param {Function} callback
     * @return {Object} appframework object with elements in it
     * @title $.map(elements,callback)
     */
    map(collection: any[], fn: (item: any, index: number) => any): any[];

    /**
     * Iterates through elements and executes a callback.  Returns if false
     ```
     $.each([1,2],function(ind){console.log(ind);});
     ```

     * @param {Array|Object} elements
     * @param {Function} callback
     * @return {Array} elements
     * @title $.each(elements,callback)
     */
    each(collection: any[], fn: (index: number, item: any) => any): void;
    each(collection: any, fn: (key: string, value: any) => any): void;

    /**
     * Extends an object with additional arguments
     ```
     $.extend({foo:'bar'});
     $.extend(element,{foo:'bar'});
     ```

     * @param {Object} [target] element
     * @param any number of additional arguments
     * @return {Object} [target]
     * @title $.extend(target,{params})
     */
    extend(target: any, ...sources: any[]): any;

    /**
     * Checks to see if the parameter is an array
     ```
     var arr=[];
     $.isArray(arr);
     ```

     * @param {Object} element
     * @return {Boolean}
     * @example $.isArray([1]);
     * @title $.isArray(param)
     */
    isArray(object: any): boolean;

    /**
     * Checks to see if the parameter is a function
     ```
     var func=function(){};
     $.isFunction(func);
     ```

     * @param {Object} element
     * @return {Boolean}
     * @title $.isFunction(param)
     */
    isFunction(object: any): boolean;

    /**
     * Checks to see if the parameter is a object
     ```
     var foo={bar:'bar'};
     $.isObject(foo);
     ```

     * @param {Object} element
     * @return {Boolean}
     * @title $.isObject(param)
     */
    isObject(object: any): boolean;

    /**
     * Prototype for afm object.  Also extens $.fn
     */
    fn: Object;

    /* AJAX settings */
    ajaxSettings: appFrameworkAjaxSettings;

    /**
     * Execute a jsonP call, allowing cross domain scripting
     * options.url - URL to call
     * options.success - Success function to call
     * options.error - Error function to call
     ```
     $.jsonP({url:'mysite.php?callback=?&foo=bar',success:function(){},error:function(){}});
     ```

     * @param {Object} options
     * @title $.jsonP(options)
     */
    jsonP(options: appFrameworkAjaxSettings): {};

    /**
     * Execute an Ajax call with the given options
     * options.type - Type of request
     * options.beforeSend - function to execute before sending the request
     * options.success - success callback
     * options.error - error callback
     * options.complete - complete callback - callled with a success or error
     * options.timeout - timeout to wait for the request
     * options.url - URL to make request against
     * options.contentType - HTTP Request Content Type
     * options.headers - Object of headers to set
     * options.dataType - Data type of request
     * options.data - data to pass into request.  $.param is called on objects
     ```
     var opts={
            type:"GET",
            success:function(data){},
            url:"mypage.php",
            data:{bar:'bar'},
            }
     $.ajax(opts);
     ```

     * @param {Object} options
     * @title $.ajax(options)
     */
    ajax(options: appFrameworkAjaxSettings): XMLHttpRequest;

    /**
     * Shorthand call to an Ajax GET request
     ```
     $.get("mypage.php?foo=bar",function(data){});
     ```

     * @param {String} url to hit
     * @param {Function} success
     * @title $.get(url,success)
     */
    get(url: string, fn: (data: any, status?: string, xhr?: XMLHttpRequest) => void): XMLHttpRequest;

    /**
     * Shorthand call to an Ajax POST request
     ```
     $.post("mypage.php",{bar:'bar'},function(data){});
     ```

     * @param {String} url to hit
     * @param {Object} [data] to pass in
     * @param {Function} success
     * @param {String} [dataType]
     * @title $.post(url,[data],success,[dataType])
     */
    post(url: string, fn: (data: any, status?: string, xhr?: XMLHttpRequest) => void, dataType?: string): XMLHttpRequest;
    post(url: string, data: any, fn: (data: any, status?: string, xhr?: XMLHttpRequest) => void, dataType?: string): XMLHttpRequest;

    /**
     * Shorthand call to an Ajax request that expects a JSON response
     ```
     $.getJSON("mypage.php",{bar:'bar'},function(data){});
     ```

     * @param {String} url to hit
     * @param {Object} [data]
     * @param {Function} [success]
     * @title $.getJSON(url,data,success)
     */
    getJSON(url: string, fn: (data: any, status?: string, xhr?: XMLHttpRequest) => void): XMLHttpRequest;
    getJSON(url: string, data: any, fn: (data: any, status: string, xhr: XMLHttpRequest) => void ): XMLHttpRequest;

    /**
     * Converts an object into a key/value par with an optional prefix.  Used for converting objects to a query string
     ```
     var obj={
            foo:'foo',
            bar:'bar'
            }
     var kvp=$.param(obj,'data');
     ```

     * @param {Object} object
     * @param {String} [prefix]
     * @return {String} Key/value pair representation
     * @title $.param(object,[prefix];
     */
    param(object: any, prefix?: string): string;

    /**
     * Used for backwards compatibility.  Uses native JSON.parse function
     ```
     var obj=$.parseJSON("{\"bar\":\"bar\"}");
     ```

     * @params {String} string
     * @return {Object}
     * @title $.parseJSON(string)
     */
    parseJSON(str: string): any;

    /**
     * Helper function to convert XML into  the DOM node representation
     ```
     var xmlDoc=$.parseXML("<xml><foo>bar</foo></xml>");
     ```

     * @param {String} string
     * @return {Object} DOM nodes
     * @title $.parseXML(string)
     */
    parseXML(str: string): any;

    /**
     * Utility function to create a psuedo GUID
     ```
     var id= $.uuid();
     ```
     * @title $.uuid
     */
    uuid(): string;

    /**
     * Gets the css matrix, or creates a fake one
     ```
     $.getCssMatrix(domElement)
     ```
     @returns matrix with postion
     */
    getCssMatrix(node: HTMLElement): appFrameworkCssMatrix;
    getCssMatrix(elem: appFrameworkCollection): appFrameworkCssMatrix;

    /**
     * $.create - a faster alertnative to $("<div id='main'>this is some text</div>");
     ```
     $.create("div",{id:'main',innerHTML:'this is some text'});
     $.create("<div id='main'>this is some text</div>");
     ```
     * @param {String} DOM Element type or html
     * @param [{Object}] properties to apply to the element
     * @return {Object} Returns an appframework object
     * @title $.create(type,[params])
     */
    create(type: string, params?: any): appFrameworkCollection;

    /**
     * $.query  - a faster alertnative to $("div");
     ```
     $.query(".panel");
     ```
     * @param {String} selector
     * @param {Object} [context]
     * @return {Object} Returns an appframework object
     * @title $.query(selector,[context])
     */
    query(selector: string, context?: any): appFrameworkCollection;

    /**
     * Creates a custom event to be used internally.
     * @param {String} type
     * @param {Object} [properties]
     * @return {event} a custom event that can then be dispatched
     * @title $.Event(type,props);
     */
    Event(type: string, props: any): any;

    /* The following are for events on objects */
    /**
     * Bind an event to an object instead of a DOM Node
     ```
     $.bind(this,'event',function(){});
     ```
     * @param {Object} object
     * @param {String} event name
     * @param {Function} function to execute
     * @title $.bind(object,event,function);
     */
    bind(object: any, event: string, fn: Function): void;

    /**
     * Trigger an event to an object instead of a DOM Node
     ```
     $.trigger(this,'event',arguments);
     ```
     * @param {Object} object
     * @param {String} event name
     * @param {Array} arguments
     * @title $.trigger(object,event,argments);
     */
    trigger(object: any, event: string, args?: any[]): void;

    /**
     * Unbind an event to an object instead of a DOM Node
     ```
     $.unbind(this,'event',function(){});
     ```
     * @param {Object} object
     * @param {String} event name
     * @param {Function} function to execute
     * @title $.unbind(object,event,function);
     */
    unbind(object: any, event: string, fn: Function): void;

    /**
     * Creates a proxy function so you can change the 'this' context in the function
     * Update: now also allows multiple argument call or for you to pass your own arguments
     ```
     var newObj={foo:bar}
     $("#main").bind("click",$.proxy(function(evt){console.log(this)},newObj);

     or

     ( $.proxy(function(foo, bar){console.log(this+foo+bar)}, newObj) )('foo', 'bar');

     or

     ( $.proxy(function(foo, bar){console.log(this+foo+bar)}, newObj, ['foo', 'bar']) )();
     ```
     * @param {Function} Callback
     * @param {Object} Context
     * @title $.proxy(callback,context);
     */
    proxy(callback: Function, context: any): void;

    /**
     * Function to clean up node content to prevent memory leaks
     ```
     $.cleanUpContent(node,itself,kill)
     ```
     * @param {HTMLNode} node
     * @param {Bool} kill itself
     * @param {bool} Kill nodes
     * @title $.cleanUpContent(node,itself,kill)
     */
    cleanUpContent(node: HTMLElement, itself?: boolean, kill?: boolean): void;

    /**
     * This adds a command to execute in the JS stack, but is faster then setTimeout
     ```
     $.asap(function,context,args)
     ```
     * @param {Function} function
     * @param {Object} context
     * @param {Array} arguments
     */
    asap(callback: Function, context?: any, args?: any[]): void;

    /**
     * this function executes javascript in HTML.
     ```
     $.parseJS(content)
     ```
     * @param {String|DOM} content
     * @title $.parseJS(content);
     */
    parseJS(content: string): void;
    parseJS(content: HTMLElement): void;

    /**
     * Helper function to parse the user agent.  Sets the following
     * .os.webkit
     * .os.android
     * .os.ipad
     * .os.iphone
     * .os.webos
     * .os.touchpad
     * .os.blackberry
     * .os.opera
     * .os.fennec
     * .os.ie
     * .os.ieTouch
     * .os.supportsTouch
     * .os.playbook
     * .feat.nativetouchScroll
     * @api private
     */
    os: {
        webkit: boolean;
        android: boolean;
        androidICS: boolean;
        ipad: boolean;
        iphone: boolean;
        ios7: boolean;
        webos: boolean;
        touchpad: boolean;
        ios: boolean;
        playbook: boolean;
        blackberry: boolean;
        blackberry10: boolean;
        chrome: boolean;
        opera: boolean;
        fennec: boolean;
        ie: boolean;
        ieTouch: boolean;
        supportsTouch: boolean;
    };

    feat: {
        nativeTouchScroll: boolean;
        cssPrefix: string;
        cssTransformStart: string;
        cssTransformEnd: string;
    }
}

interface appFrameworkCollection {
    reduce(callbackfn: (previousValue: appFrameworkCollection, currentValue: appFrameworkCollection, currentIndex: number, array: appFrameworkCollection[]) => appFrameworkCollection, initialValue?: appFrameworkCollection): appFrameworkCollection;
    push(...items: appFrameworkCollection[]): number;
    indexOf(searchElement: appFrameworkCollection, fromIndex?: number): number;
    concat(...items: appFrameworkCollection[]): appFrameworkCollection[];
    slice(start: number, end?: number): appFrameworkCollection[];
    length: number;

    /**
     * This is a wrapper to $.map on the selected elements
     ```
     $().map(function(){this.value+=ind});
     ```

     * @param {Function} callback
     * @return {Object} an appframework object
     * @title $().map(function)
     */
    map(fn: (index: number, item: any) => any): appFrameworkCollection;
    /**
     * Iterates through all elements and applys a callback function
     ```
     $().each(function(){console.log(this.value)});
     ```

     * @param {Function} callback
     * @return {Object} an appframework object
     * @title $().each(function)
     */
    each(fn: (index: number, item: any) => any): appFrameworkCollection;
    forEach(fn: (item: any, index: number) => any): void;

    /**
     * This is executed when DOMContentLoaded happens, or after if you've registered for it.
     ```
     $(document).ready(function(){console.log('I'm ready');});
     ```

     * @param {Function} callback
     * @return {Object} an appframework object
     * @title $().ready(function)
     */
    ready(fn: Function): appFrameworkStatic;

    /**
     * Searches through the collection and reduces them to elements that match the selector
     ```
     $("#foo").find('.bar');
     $("#foo").find($('.bar'));
     $("#foo").find($('.bar').get(0));
     ```

     * @param {String|Object|Array} selector
     * @return {Object} an appframework object filtered
     * @title $().find(selector)

     */
    find(selector: string): appFrameworkCollection;

    /**
     * Gets or sets the innerHTML for the collection.
     * If used as a get, the first elements innerHTML is returned
     ```
     $("#foo").html(); //gets the first elements html
     $("#foo").html('new html');//sets the html
     $("#foo").html('new html',false); //Do not do memory management cleanup
     ```

     * @param {String} html to set
     * @param {Bool} [cleanup] - set to false for performance tests and if you do not want to execute memory management cleanup
     * @return {Object} an appframework object
     * @title $().html([html])
     */
    html(): string;
    html(html: string): appFrameworkCollection;
    html(html: string, cleanup: boolean): appFrameworkCollection;

    /**
     * Gets or sets the innerText for the collection.
     * If used as a get, the first elements innerText is returned
     ```
     $("#foo").text(); //gets the first elements text;
     $("#foo").text('new text'); //sets the text
     ```

     * @param {String} text to set
     * @return {Object} an appframework object
     * @title $().text([text])
     */
    text(): string;
    text(text: string): appFrameworkCollection;

    /**
     * Gets or sets a css property for the collection
     * If used as a get, the first elements css property is returned
     * This will add px to properties that need it.
     ```
     $().css("background"); // Gets the first elements background
     $().css("background","red")  //Sets the elements background to red
     ```

     * @param {String} attribute to get
     * @param {String} value to set as
     * @return {Object} an appframework object
     * @title $().css(attribute,[value])
     */
    css(property: string): any;
    css(property: string, value: any): appFrameworkCollection;
    css(properties: any): appFrameworkCollection;

    /**
     * Performs a css vendor specific transform:translate operation on the collection.
     *
     ```
     $("#main").cssTranslate('200px,0,0');
     ```
     * @param {String} Transform values
     * @return {Object} an appframework object
     * @title $().vendorCss(value)
     */
    vendorCss(transform: string): appFrameworkCollection;

    /**
     * Gets the computed style of CSS values
     *
     ```
     $("#main").computedStyle('display');
     ```
     * @param {String} css property
     * @return {Int|String|Float|} css vlaue
     * @title $().computedStyle()
     */
    computedStyle(css: string): appFrameworkCollection;

    /**
     * Sets the innerHTML of all elements to an empty string
     ```
     $().empty();
     ```

     * @return {Object} an appframework object
     * @title $().empty()
     */
    empty(): appFrameworkCollection;

    /**
     * Sets the elements display property to "none".
     * This will also store the old property into an attribute for hide
     ```
     $().hide();
     ```

     * @return {Object} an appframework object
     * @title $().hide()
     */
    hide(): appFrameworkCollection;

    /**
     * Shows all the elements by setting the css display property
     * We look to see if we were retaining an old style (like table-cell) and restore that, otherwise we set it to block
     ```
     $().show();
     ```

     * @return {Object} an appframework object
     * @title $().show()
     */
    show(): appFrameworkCollection;

    /**
     * Toggle the visibility of a div
     ```
     $().toggle();
     $().toggle(true); //force showing
     ```

     * @param {Boolean} [show] -force the hiding or showing of the element
     * @return {Object} an appframework object
     * @title $().toggle([show])
     */
    toggle(show?: boolean): appFrameworkCollection;

    /**
     * Gets or sets an elements value
     * If used as a getter, we return the first elements value.  If nothing is in the collection, we return undefined
     ```
     $().value; //Gets the first elements value;
     $().value="bar"; //Sets all elements value to bar
     ```

     * @param {String} [value] to set
     * @return {String|Object} A string as a getter, appframework object as a setter
     * @title $().val([value])
     */
    val(): string;
    val(value: string): appFrameworkCollection;

    /**
     * Gets or sets an attribute on an element
     * If used as a getter, we return the first elements value.  If nothing is in the collection, we return undefined
     ```
     $().attr("foo"); //Gets the first elements 'foo' attribute
     $().attr("foo","bar");//Sets the elements 'foo' attribute to 'bar'
     $().attr("foo",{bar:'bar'}) //Adds the object to an internal cache
     ```

     * @param {String|Object} attribute to act upon.  If it's an object (hashmap), it will set the attributes based off the kvp.
     * @param {String|Array|Object|function} [value] to set
     * @return {String|Object|Array|Function} If used as a getter, return the attribute value.  If a setter, return an appframework object
     * @title $().attr(attribute,[value])
     */
    attr(attribute: string): any;
    attr(attributeHash: Object): appFrameworkCollection;
    attr(attribute: string, value: string): appFrameworkCollection;
    attr(attribute: string, value: any): appFrameworkCollection;

    /**
     * Removes an attribute on the elements
     ```
     $().removeAttr("foo");
     ```

     * @param {String} attributes that can be space delimited
     * @return {Object} appframework object
     * @title $().removeAttr(attribute)
     */
    removeAttr(attribute: string): appFrameworkCollection;

    /**
     * Gets or sets a property on an element
     * If used as a getter, we return the first elements value.  If nothing is in the collection, we return undefined
     ```
     $().prop("foo"); //Gets the first elements 'foo' property
     $().prop("foo","bar");//Sets the elements 'foo' property to 'bar'
     $().prop("foo",{bar:'bar'}) //Adds the object to an internal cache
     ```

     * @param {String|Object} property to act upon.  If it's an object (hashmap), it will set the attributes based off the kvp.
     * @param {String|Array|Object|function} [value] to set
     * @return {String|Object|Array|Function} If used as a getter, return the property value.  If a setter, return an appframework object
     * @title $().prop(property,[value])
     */
    prop(attribute: string): any;
    prop(attributeHash: Object): appFrameworkCollection;
    prop(attribute: string, value: string): appFrameworkCollection;
    prop(attribute: string, value: any): appFrameworkCollection;

    /**
     * Removes a property on the elements
     ```
     $().removeProp("foo");
     ```

     * @param {String} properties that can be space delimited
     * @return {Object} appframework object
     * @title $().removeProp(attribute)
     */
    removeProp(attribute: string): appFrameworkCollection;

    /**
     * Removes elements based off a selector
     ```
     $().remove();  //Remove all
     $().remove(".foo");//Remove off a string selector
     var element=$("#foo").get(0);
     $().remove(element); //Remove by an element
     $().remove($(".foo"));  //Remove by a collection

     ```

     * @param {String|Object|Array} selector to filter against
     * @return {Object} appframework object
     * @title $().remove(selector)
     */
    remove(): appFrameworkCollection;
    remove(selector: string): appFrameworkCollection;
    remove(element: HTMLElement): appFrameworkCollection;
    remove(elements: any[]): appFrameworkCollection;
    remove(elements: appFrameworkCollection): appFrameworkCollection;

    /**
     * Adds a css class to elements.
     ```
     $().addClass("selected");
     ```

     * @param {String} classes that are space delimited
     * @return {Object} appframework object
     * @title $().addClass(name)
     */
    addClass(className: string): appFrameworkCollection;

    /**
     * Removes a css class from elements.
     ```
     $().removeClass("foo"); //single class
     $().removeClass("foo selected");//remove multiple classess
     ```

     * @param {String} classes that are space delimited
     * @return {Object} appframework object
     * @title $().removeClass(name)
     */
    removeClass(className: string): appFrameworkCollection;

    /**
    * Adds or removes a css class to elements.
        ```
        $().toggleClass("selected");
        ```

    * @param {String} classes that are space delimited
    * @param {Boolean} [state] force toggle to add or remove classes
    * @return {Object} appframework object
    * @title $().toggleClass(name)
    */
    toggleClass(name: string, state?: boolean): appFrameworkCollection;

    /**
     * Replaces a css class on elements.
     ```
     $().replaceClass("on", "off");
     ```

     * @param {String} classes that are space delimited
     * @param {String} classes that are space delimited
     * @return {Object} appframework object
     * @title $().replaceClass(old, new)
     */
    replaceClass(oldClassName: string, newClassName: string): appFrameworkCollection;

    /**
     * Checks to see if an element has a class.
     ```
     $().hasClass('foo');
     $().hasClass('foo',element);
     ```

     * @param {String} class name to check against
     * @param {Object} [element] to check against
     * @return {Boolean}
     * @title $().hasClass(name,[element])
     */
    hasClass(className: string, element: HTMLElement): boolean;

    /**
     * Appends to the elements
     * We boil everything down to an appframework object and then loop through that.
     * If it's HTML, we create a dom element so we do not break event bindings.
     * if it's a script tag, we evaluate it.
     ```
     $().append("<div></div>"); //Creates the object from the string and appends it
     $().append($("#foo")); //Append an object;
     ```

     * @param {String|Object} Element/string to add
     * @param {Boolean} [insert] insert or append
     * @return {Object} appframework object
     * @title $().append(element,[insert])
     */
    append(content: any): appFrameworkCollection;

    /**
     * Appends the current collection to the selector
     ```
     $().appendTo("#foo"); //Append an object;
     ```

     * @param {String|Object} Selector to append to
     * @param {Boolean} [insert] insert or append
     * @title $().appendTo(element,[insert])
     */
    appendTo(target: any): appFrameworkCollection;

    /**
     * Prepends the current collection to the selector
     ```
     $().prependTo("#foo"); //Prepend an object;
     ```

     * @param {String|Object} Selector to prepent to
     * @title $().prependTo(element)
     */
    prependTo(target: any): appFrameworkCollection;

    /**
     * Prepends to the elements
     * This simply calls append and sets insert to true
     ```
     $().prepend("<div></div>");//Creates the object from the string and appends it
     $().prepend($("#foo")); //Prepends an object
     ```

     * @param {String|Object} Element/string to add
     * @return {Object} appframework object
     * @title $().prepend(element)
     */
    prepend(content: any): appFrameworkCollection;

    /**
     * Inserts collection before the target (adjacent)
     ```
     $().insertBefore(af("#target"));
     ```

     * @param {String|Object} Target
     * @title $().insertBefore(target);
     */
    insertBefore(target: any): appFrameworkCollection;

    /**
     * Inserts collection after the target (adjacent)
     ```
     $().insertAfter(af("#target"));
     ```
     * @param {String|Object} target
     * @title $().insertAfter(target);
     */
    insertAfter(target: any): void;

    /**
     * Returns the raw DOM element.
     ```
     $().get(0); //returns the first element
     $().get(2);// returns the third element
     ```

     * @param {Int} [index]
     * @return {Object} raw DOM element
     * @title $().get([index])
     */
    get(): HTMLElement[];
    get(index: number): HTMLElement;

    /**
     * Returns the offset of the element, including traversing up the tree
     ```
     $().offset();
     ```

     * @return {Object} with left, top, width and height properties
     * @title $().offset()
     */
    offset(): {
        left: number;
        top: number;
        right: number;
        bottom: number;
        width: number;
        height: number;
    };

    /**
     * returns the height of the element, including padding on IE
     ```
     $().height();
     ```
     * @return {string} height
     * @title $().height()
     */
    height(): string;

    /**
     * returns the width of the element, including padding on IE
     ```
     $().width();
     ```
     * @return {string} width
     * @title $().width()
     */
    width(): string;

    /**
     * Returns the parent nodes of the elements based off the selector
     ```
     $("#foo").parent('.bar');
     $("#foo").parent($('.bar'));
     $("#foo").parent($('.bar').get(0));
     ```

     * @param {String|Array|Object} [selector]
     * @return {Object} appframework object with unique parents
     * @title $().parent(selector)
     */
    parent(selector?: any): appFrameworkCollection;

    /**
     * Returns the parents of the elements based off the selector (traversing up until html document)
     ```
     $("#foo").parents('.bar');
     $("#foo").parents($('.bar'));
     $("#foo").parents($('.bar').get(0));
     ```

     * @param {String|Array|Object} [selector]
     * @return {Object} appframework object with unique parents
     * @title $().parents(selector)
     */
    parents(selector?: any): appFrameworkCollection;

    /**
     * Returns the child nodes of the elements based off the selector
     ```
     $("#foo").children('.bar'); //Selector
     $("#foo").children($('.bar')); //Objects
     $("#foo").children($('.bar').get(0)); //Single element
     ```

     * @param {String|Array|Object} [selector]
     * @return {Object} appframework object with unique children
     * @title $().children(selector)
     */
    children(selector?: any): appFrameworkCollection;

    /**
     * Returns the siblings of the element based off the selector
     ```
     $("#foo").siblings('.bar'); //Selector
     $("#foo").siblings($('.bar')); //Objects
     $("#foo").siblings($('.bar').get(0)); //Single element
     ```

     * @param {String|Array|Object} [selector]
     * @return {Object} appframework object with unique siblings
     * @title $().siblings(selector)
     */
    siblings(selector?: any): appFrameworkCollection;

    /**
     * Returns the closest element based off the selector and optional context
     ```
     $("#foo").closest('.bar'); //Selector
     $("#foo").closest($('.bar')); //Objects
     $("#foo").closest($('.bar').get(0)); //Single element
     ```

     * @param {String|Array|Object} selector
     * @param {Object} [context]
     * @return {Object} Returns an appframework object with the closest element based off the selector
     * @title $().closest(selector,[context]);
     */
    closest(selector?: any): appFrameworkCollection;

    /**
     * Filters elements based off the selector
     ```
     $("#foo").filter('.bar'); //Selector
     $("#foo").filter($('.bar')); //Objects
     $("#foo").filter($('.bar').get(0)); //Single element
     ```

     * @param {String|Array|Object} selector
     * @return {Object} Returns an appframework object after the filter was run
     * @title $().filter(selector);
     */
    filter(selector?: any): appFrameworkCollection;

    /**
     * Basically the reverse of filter.  Return all elements that do NOT match the selector
     ```
     $("#foo").not('.bar'); //Selector
     $("#foo").not($('.bar')); //Objects
     $("#foo").not($('.bar').get(0)); //Single element
     ```

     * @param {String|Array|Object} selector
     * @return {Object} Returns an appframework object after the filter was run
     * @title $().not(selector);
     */
    not(selector?: any): appFrameworkCollection;

    /**
     * Gets or set data-* attribute parameters on elements (when a string)
     * When used as a getter, it's only the first element
     ```
     $().data("foo"); //Gets the data-foo attribute for the first element
     $().data("foo","bar"); //Sets the data-foo attribute for all elements
     $().data("foo",{bar:'bar'});//object as the data
     ```

     * @param {String} key
     * @param {String|Array|Object} value
     * @return {String|Object} returns the value or appframework object
     * @title $().data(key,[value]);
     */
    data(attribute: string): any;
    data(attribute: string, value: string): appFrameworkCollection;
    data(attribute: string, value: any): appFrameworkCollection;

    /**
     * Rolls back the appframework elements when filters were applied
     * This can be used after .not(), .filter(), .children(), .parent()
     ```
     $().filter(".panel").end(); //This will return the collection BEFORE filter is applied
     ```

     * @return {Object} returns the previous appframework object before filter was applied
     * @title $().end();
     */
    end(): appFrameworkCollection;

    /**
     * Clones the nodes in the collection.
     ```
     $().clone();// Deep clone of all elements
     $().clone(false); //Shallow clone
     ```

     * @param {Boolean} [deep] - do a deep copy or not
     * @return {Object} appframework object of cloned nodes
     * @title $().clone();
     */
    clone(deep?: boolean): appFrameworkCollection;

    /**
     * Returns the number of elements in the collection
     ```
     $().size();
     ```

     * @return {Int}
     * @title $().size();
     */
    size(): number;

    /**
     * Serailizes a form into a query string
     ```
     $().serialize();
     ```
     * @return {String}
     * @title $().serialize()
     */
    serialize(): string;

    /* added in 1.2 */
    /**
     * Reduce the set of elements based off index
     ```
     $().eq(index)
     ```
     * @param {Int} index - Index to filter by. If negative, it will go back from the end
     * @return {Object} appframework object
     * @title $().eq(index)
     */
    eq(index: number): appFrameworkCollection;

    /**
     * Returns the index of the selected element in the collection
     ```
     $().index(elem)
     ```
     * @param {String|Object} element to look for.  Can be a selector or object
     * @return integer - index of selected element
     * @title $().index(elem)
     */
    index(): number;
    index(selector: any): number;

    /**
     * Returns boolean if the object is a type of the selector
     ```
     $().is(selector)
     ```
     * param {String|Object} selector to act upon
     * @return boolean
     * @title $().is(selector)
     */
    is(selector: any): number;

    /**
     * Binds an event to each element in the collection and executes the callback
     ```
     $().bind('click',function(){console.log('I clicked '+this.id);});
     ```

     * @param {String|Object} event
     * @param {Function} callback
     * @return {Object} appframework object
     * @title $().bind(event,callback)
     */
    bind(eventHash: Object): appFrameworkCollection;
    bind(eventName: string, fn: (e: Event) => any): appFrameworkCollection;

    /**
     * Unbinds an event to each element in the collection.  If a callback is passed in, we remove just that one, otherwise we remove all callbacks for those events
     ```
     $().unbind('click'); //Unbinds all click events
     $().unbind('click',myFunc); //Unbinds myFunc
     ```

     * @param {String|Object} event
     * @param {Function} [callback]
     * @return {Object} appframework object
     * @title $().unbind(event,[callback]);
     */
    unbind(eventHash: {}): appFrameworkCollection;
    unbind(eventName?: string): appFrameworkCollection;
    unbind(eventName: string, fn?: (e: Event) => any): appFrameworkCollection;

    /**
     * Binds an event to each element in the collection that will only execute once.  When it executes, we remove the event listener then right away so it no longer happens
     ```
     $().one('click',function(){console.log('I was clicked once');});
     ```

     * @param {String|Object} event
     * @param {Function} [callback]
     * @return appframework object
     * @title $().one(event,callback);
     */
    one(eventHash: {}): appFrameworkCollection;
    one(eventName: string, fn: (e: Event) => any): appFrameworkCollection;

    /**
     * Delegate an event based off the selector.  The event will be registered at the parent level, but executes on the selector.
     ```
     $("#div").delegate("p",'click',callback);
     ```

     * @param {String|Array|Object} selector
     * @param {String|Object} event
     * @param {Function} callback
     * @return {Object} appframework object
     * @title $().delegate(selector,event,callback)
     */
    delegate(selector: any, eventHash: {}): appFrameworkCollection;
    delegate(selector: any, eventName: string, fn: (e: Event) => any): appFrameworkCollection;

    /**
     * Unbinds events that were registered through delegate.  It acts upon the selector and event.  If a callback is specified, it will remove that one, otherwise it removes all of them.
     ```
     $("#div").undelegate("p",'click',callback);//Undelegates callback for the click event
     $("#div").undelegate("p",'click');//Undelegates all click events
     ```

     * @param {String|Array|Object} selector
     * @param {String|Object} event
     * @param {Function} callback
     * @return {Object} appframework object
     * @title $().undelegate(selector,event,[callback]);
     */
    undelegate(selector: any, eventHash: {}): appFrameworkCollection;
    undelegate(selector: any, eventName: string, fn: (e: Event) => any): appFrameworkCollection;

    /**
     * Similar to delegate, but the function parameter order is easier to understand.
     * If selector is undefined or a function, we just call .bind, otherwise we use .delegate
     ```
     $("#div").on("click","p",callback);
     ```

     * @param {String|Array|Object} selector
     * @param {String|Object} event
     * @param {Function} callback
     * @return {Object} appframework object
     * @title $().on(event,selector,callback);
     */
    on(eventHash: {}, selector?: any): appFrameworkCollection;
    on(eventName: string, fn: (e: Event) => any): appFrameworkCollection;
    on(eventName: string, selector: string, fn: (e: Event) => any): appFrameworkCollection;

    /**
     * Removes event listeners for .on()
     * If selector is undefined or a function, we call unbind, otherwise it's undelegate
     ```
     $().off("click","p",callback); //Remove callback function for click events
     $().off("click","p") //Remove all click events
     ```

     * @param {String|Object} event
     * @param {String|Array|Object} selector
     * @param {Sunction} callback
     * @return {Object} appframework object
     * @title $().off(event,selector,[callback])
     */
    off(eventHash: {}, selector?: any): appFrameworkCollection;
    off(eventName: string, fn: (e: Event) => any): appFrameworkCollection;
    off(eventName: string, selector: string, fn: (e: Event) => any): appFrameworkCollection;

    /**
     This triggers an event to be dispatched.  Usefull for emulating events, etc.
     ```
     $().trigger("click",{foo:'bar'});//Trigger the click event and pass in data
     ```

     * @param {String|Object} event
     * @param {Object} [data]
     * @return {Object} appframework object
     * @title $().trigger(event,data);
     */
    trigger(eventName: string, data?: any): appFrameworkCollection;
    trigger(eventHash: {}, data?: any): appFrameworkCollection;

    /**
     custom events since people want to do $().click instead of $().bind("click")
     */
    click(fn?: (e: Event) => any): appFrameworkCollection;

    /**
     custom events since people want to do $().keydown instead of $().bind("keydown")
     */
    keydown(fn?: (e: Event) => any): appFrameworkCollection;

    /**
     custom events since people want to do $().keyup instead of $().bind("keyup")
     */
    keyup(fn?: (e: Event) => any): appFrameworkCollection;

    /**
     custom events since people want to do $().keypress instead of $().bind("keypress")
     */
    keypress(fn?: (e: Event) => any): appFrameworkCollection;

    /**
     custom events since people want to do $().submit instead of $().bind("submit")
     */
    submit(fn?: (e: Event) => any): appFrameworkCollection;

    /**
     custom events since people want to do $().load instead of $().bind("load")
     */
    load(fn?: (e: Event) => any): appFrameworkCollection;

    /**
     custom events since people want to do $().resize instead of $().bind("resize")
     */
    resize(fn?: (e: Event) => any): appFrameworkCollection;

    /**
     custom events since people want to do $().change instead of $().bind("change")
     */
    change(fn?: (e: Event) => any): appFrameworkCollection;

    /**
     custom events since people want to do $().select instead of $().bind("select")
     */
    select(fn?: (e: Event) => any): appFrameworkCollection;

    /**
     custom events since people want to do $().error instead of $().bind("error")
     */
    error(fn?: (e: Event) => any): appFrameworkCollection;

    /**
     custom events since people want to do $().focus instead of $().bind("focus")
     */
    focus(fn?: (e: Event) => any): appFrameworkCollection;

    /**
     custom events since people want to do $().blur instead of $().bind("blur")
     */
    blur(fn?: (e: Event) => any): appFrameworkCollection;
}

interface appFrameworkAjaxSettings {
    type?: string;
    beforeSend?: (xhr: XMLHttpRequest, settings: appFrameworkAjaxSettings) => boolean;
    success?: (data: any, status: string, xhr: XMLHttpRequest) => void;
    error?: (xhr: XMLHttpRequest, errorType: string, error: Error) => void;
    complete?: (xhr: XMLHttpRequest, status: string) => void;
    timeout?: number;
    url?: string;
    contentType?: string;
    headers?: any;
    dataType?: string;
    data?: any;
    context?: any;
    crossDomain?: boolean;
}

interface appFrameworkCssMatrix {
    a: number;
    b: number;
    c: number;
    d: number;
    e: number;
    f: number;
}

declare var af: (fn: ($: appFrameworkStatic) => void) => void;
declare var $: appFrameworkStatic;