DefinitelyTyped/types/openui5/sap.ui.d.ts

// Type definitions for OpenUI5 1.40
// Project: http://openui5.org/
// Definitions by: Lukas May <https://www.dscsag.com/>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

declare namespace sap {
  namespace ui {

    /**
     * Creates a new instance of a <code>Component</code> or returns the instanceof an existing
     * <code>Component</code>.If you want to look up an existing <code>Component</code> you can callthis
     * function with a Component ID as parameter:<pre>  var oComponent =
     * sap.ui.component(sComponentId);</pre>To create a new instance of a component you pass a component
     * configurationobject into this function:<pre>  var oComponent = sap.ui.component({    name:
     * "my.Component",    url: "my/component/location",    id: "myCompId1"  });</pre>
     * @since 1.15.0
     * @param vConfig ID of an existing Component or the configuration object to create the Component
     * @returns the Component instance or a Promise in case of asynchronous loading
    */
    function component(vConfig: string | any): sap.ui.core.Component | JQueryPromise<any>;

    /**
     * Defines a controller class or creates an instance of an already defined controller class.When a name
     * and a controller implementation object is given, a new controller classof the given name is created.
     * The members of the implementation object will be copiedinto each new instance of that controller
     * class (shallow copy).<b>Note</b>: as the members are shallow copied, controller instances will share
     * all object values.This might or might not be what applications expect.If only a name is given, a new
     * instance of the named controller class is returned.
     * @param sName The controller name
     * @param oControllerImpl An object literal defining the methods and properties of the controller
     * @returns void or the new controller instance, depending on the use case
    */
    function controller(sName: string, oControllerImpl?: any): void | sap.ui.core.mvc.Controller;

    /**
     * Defines a Javascript module with its name, its dependencies and a module value or factory.The
     * typical and only suggested usage of this method is to have one single, top level call
     * to<code>sap.ui.define</code> in one Javascript resource (file). When a module is requested by
     * itsname for the first time, the corresponding resource is determined from the name and the
     * current{@link jQuery.sap.registerResourcePath configuration}. The resource will be loaded and
     * executedwhich in turn will execute the top level <code>sap.ui.define</code> call.If the module name
     * was omitted from that call, it will be substituted by the name that was used torequest the module.
     * As a preparation step, the dependencies as well as their transitive dependencies,will be loaded.
     * Then, the module value will be determined: if a static value (object, literal) wasgiven, that value
     * will be the module value. If a function was given, that function will be called(providing the module
     * values of the declared dependencies as parameters to the function) and itsreturn value will be used
     * as module value. The framework internally associates the resulting valuewith the module name and
     * provides it to the original requestor of the module. Whenever the moduleis requested again, the same
     * value will be returned (modules are executed only once).<i>Example:</i><br>The following example
     * defines a module "SomeClass", but doesn't hard code the module name.If stored in a file
     * 'sap/mylib/SomeClass.js', it can be requested as 'sap/mylib/SomeClass'.<pre> 
     * sap.ui.define(['./Helper', 'sap/m/Bar'], function(Helper,Bar) {    // create a new class    var
     * SomeClass = function();    // add methods to its prototype    SomeClass.prototype.foo = function() {
     *        // use a function from the dependency 'Helper' in the same package (e.g. 'sap/mylib/Helper' )
     *        var mSettings = Helper.foo();        // create and return a sap.m.Bar (using its local name
     * 'Bar')        return new Bar(mSettings);    }    // return the class as module value    return
     * SomeClass;  });</pre>In another module or in an application HTML page, the {@link sap.ui.require}
     * API can be usedto load the Something module and to work with
     * it:<pre>sap.ui.require(['sap/mylib/Something'], function(Something) {  // instantiate a Something
     * and call foo() on it  new Something().foo();});</pre><b>Module Name
     * Syntax</b><br><code>sap.ui.define</code> uses a simplified variant of the {@link
     * jQuery.sap.getResourcePathunified resource name} syntax for the module's own name as well as for its
     * dependencies.The only difference to that syntax is, that for <code>sap.ui.define</code>
     * and<code>sap.ui.require</code>, the extension (which always would be '.js') has to be omitted.Both
     * methods always add this extension internally.As a convenience, the name of a dependency can start
     * with the segment './' which will bereplaced by the name of the package that contains the currently
     * defined module (relative name).It is best practice to omit the name of the defined module (first
     * parameter) and to userelative names for the dependencies whenever possible. This reduces the
     * necessary configuration,simplifies renaming of packages and allows to map them to a different
     * namespace.<b>Dependency to Modules</b><br>If a dependencies array is given, each entry represents
     * the name of another module thatthe currently defined module depends on. All dependency modules are
     * loaded before the valueof the currently defined module is determined. The module value of each
     * dependency modulewill be provided as a parameter to a factory function, the order of the parameters
     * will matchthe order of the modules in the dependencies array.<b>Note:</b> the order in which the
     * dependency modules are <i>executed</i> is <b>not</b>defined by the order in the dependencies array!
     * The execution order is affected by dependencies<i>between</i> the dependency modules as well as by
     * their current state (whether a modulealready has been loaded or not). Neither module implementations
     * nor dependants that requirea module set must make any assumption about the execution order (other
     * than expressed bytheir dependencies). There is, however, one exception with regard to third party
     * libraries,see the list of limitations further down below.<b>Note:</b>a static module value (a
     * literal provided to <code>sap.ui.define</code>) cannotdepend on the module values of the depency
     * modules. Instead, modules can use a factory function,calculate the static value in that function,
     * potentially based on the dependencies, and returnthe result as module value. The same approach must
     * be taken when the module value is supposedto be a function.<b>Asynchronous
     * Contract</b><br><code>sap.ui.define</code> is designed to support real Asynchronous Module
     * Definitions (AMD)in future, although it internally still uses the the old synchronous module loading
     * of UI5.Callers of <code>sap.ui.define</code> therefore must not rely on any synchronous behaviorthat
     * they might observe with the current implementation.For example, callers of
     * <code>sap.ui.define</code> must not use the module value immediatelyafter invoking
     * <code>sap.ui.define</code>:<pre>  // COUNTER EXAMPLE HOW __NOT__ TO DO IT  // define a class
     * Something as AMD module  sap.ui.define('Something', [], function() {    var Something = function(); 
     *   return Something;  });  // DON'T DO THAT!  // accessing the class _synchronously_ after
     * sap.ui.define was called  new Something();</pre>Applications that need to ensure synchronous module
     * definition or synchronous loading of dependencies<b>MUST</b> use the old {@link jQuery.sap.declare}
     * and {@link jQuery.sap.require} APIs.<b>(No) Global References</b><br>To be in line with AMD best
     * practices, modules defined with <code>sap.ui.define</code>should not make any use of global
     * variables if those variables are also available as modulevalues. Instead, they should add
     * dependencies to those modules and use the corresponding parameterof the factory function to access
     * the module value.As the current programming model and the documentation of UI5 heavily rely on
     * global names,there will be a transition phase where UI5 enables AMD modules and local references to
     * modulevalues in parallel to the old global names. The fourth parameter of
     * <code>sap.ui.define</code>has been added to support that transition phase. When this parameter is
     * set to true, the frameworkprovides two additional functionalities<ol><li>before the factory function
     * is called, the existence of the global parent namespace for    the current module is
     * ensured</li><li>the module value will be automatically exported under a global name which is derived
     * from    the name of the module</li></ol>The parameter lets the framework know whether any of those
     * two operations is needed or not.In future versions of UI5, a central configuration option is planned
     * to suppress those 'exports'.<b>Third Party Modules</b><br>Although third party modules don't use UI5
     * APIs, they still can be listed as dependencies ina <code>sap.ui.define</code> call. They will be
     * requested and executed like UI5 modules, but theirmodule value will be <code>undefined</code>.If the
     * currently defined module needs to access the module value of such a third party module,it can access
     * the value via its global name (if the module supports such a usage).Note that UI5 temporarily
     * deactivates an existing AMD loader while it executes third party modulesknown to support AMD. This
     * sounds contradictarily at a first glance as UI5 wants to support AMD,but for now it is necessary to
     * fully support UI5 apps that rely on global names for such modules.Example:<pre>  // module
     * 'Something' wants to use third party library 'URI.js'  // It is packaged by UI5 as non-UI5-module
     * 'sap/ui/thirdparty/URI'  sap.ui.define('Something', ['sap/ui/thirdparty/URI'],
     * function(URIModuleValue) {    new URIModuleValue(); // fails as module value is undefined   
     * //global URI // (optional) declare usage of global name so that static code checks don't complain   
     * new URI(); // access to global name 'URI' works    ...  });</pre><b>Differences to
     * requireJS</b><br>The current implementation of <code>sap.ui.define</code> differs from
     * <code>requireJS</code>or other AMD loaders in several aspects:<ul><li>the name
     * <code>sap.ui.define</code> is different from the plain <code>define</code>.This has two reasons:
     * first, it avoids the impression that <code>sap.ui.define</code> isan exact implementation of an AMD
     * loader. And second, it allows the coexistence of an AMDloader (requireJS) and
     * <code>sap.ui.define</code> in one application as long as UI5 orapps using UI5 are not fully prepared
     * to run with an AMD loader</li><li><code>sap.ui.define</code> currently loads modules with
     * synchronous XHR calls. This isbasically a tribute to the synchronous history of UI5.<b>BUT:</b>
     * synchronous dependency loading and factory execution explicitly it not part ofcontract of
     * <code>sap.ui.define</code>. To the contrary, it is already clear and plannedthat asynchronous
     * loading will be implemented, at least as an alternative if not as the onlyimplementation. Also check
     * section <b>Asynchronous Contract</b> above.<br>Applications that need to ensure synchronous loading
     * of dependencies <b>MUST</b> use the old{@link jQuery.sap.require}
     * API.</li><li><code>sap.ui.define</code> does not support plugins to use other file types, formats
     * orprotocols. It is not planned to support this in future</li><li><code>sap.ui.define</code> does
     * <b>not</b> support the 'sugar' of requireJS where CommonJSstyle dependency declarations using
     * <code>sap.ui.require("something")</code> are automagicallyconverted into <code>sap.ui.define</code>
     * dependencies before executing the factory function.</li></ul><b>Limitations, Design
     * Considerations</b><br><ul><li><b>Limitation</b>: as dependency management is not supported for
     * Non-UI5 modules, the only way    to ensure proper execution order for such modules currently is to
     * rely on the order in the    dependency array. Obviously, this only works as long as
     * <code>sap.ui.define</code> uses    synchronous loading. It will be enhanced when asynchronous
     * loading is implemented.</li><li>it was discussed to enfore asynchronous execution of the module
     * factory function (e.g. with a    timeout of 0). But this would have invalidated the current
     * migration scenario where a    sync <code>jQuery.sap.require</code> call can load a
     * <code>sap.ui.define</code>'ed module.    If the module definition would not execute synchronously,
     * the synchronous contract of the    require call would be broken (default behavior in existing UI5
     * apps)</li><li>a single file must not contain multiple calls to <code>sap.ui.define</code>. Multiple
     * calls    currently are only supported in the so called 'preload' files that the UI5 merge tooling
     * produces.    The exact details of how this works might be changed in future implementations and are
     * not    yet part of the API contract</li></ul>
     * @since 1.27.0
     * @param sModuleName name of the module in simplified resource name syntax.       When omitted, the
     * loader determines the name from the request.
     * @param aDependencies list of dependencies of the module
     * @param vFactory the module value or a function that calculates the value
     * @param bExport whether an export to global names is required - should be used by SAP-owned code only
    */

    interface ComponentConfig {
      // 	the name of the Component to load
      name: string;
      // 	an alternate location from where to load the Component
      url?: string;
      // 	initial data of the Component (@see sap.ui.core.Component#getComponentData)
      componentData?: any;
      // 	the sId of the new Component
      id?: string;
      //	the mSettings of the new Component
      settings?: any;
    }
    //  Creates a new instance of a Component or returns the instance of an existing Component.
    function component(vConfig: string | ComponentConfig): JQueryPromise<sap.ui.core.Component> | sap.ui.core.Component;
    //  Defines a controller class or creates an instance of an already defined controller class.
    function controller(sName: string, oControllerImpl?: any): void | sap.ui.core.mvc.Controller;
    //  Defines a Javascript module with its name, its dependencies and a module value or factory.
    function define(vFactory: any): void;
    function define(aDependencies: any, vFactory: any): void;
    function define(sModuleName: string, aDependencies: any, vFactory: any): void;
    //  Creates 0.
    function extensionpoint(oContainer: any, sExtName: string, fnCreateDefaultContent?: any, oTargetControl?: any, sAggregationName?: string): void;
    //  Instantiate a Fragment - this method loads the Fragment content, instantiates it, and returns this content.
    function fragment(sName: string, sType: string, oController?: any): void;
    //  Retrieve the SAPUI5 Core instance for the current window.
    //  and returns it or if a library name is specified then the version info of the individual library will be returned.
    function getCore(): sap.ui.core.Core;
    // Loads the version info file (resources/sap-ui-version.json):void;
    function getVersionInfo(sLibName?: string): void;
    //  Instantiates an HTML-based Fragment.
    function htmlfragment(vFragment: any, oController?: any): sap.ui.core.Fragment;
    function htmlfragment(sId: string, vFragment: any, oController?: any): void;
    //  Defines or creates an instance of a declarative HTML view.
    function htmlview(vView: any): sap.ui.core.mvc.HTMLView;
    function htmlview(sId: string, vView: any): sap.ui.core.mvc.HTMLView;
    //  Defines OR instantiates an HTML-based Fragment.
    function jsfragment(sFragmentName: string, oController?: any): sap.ui.core.Fragment;
    function jsfragment(sId: string, sFragmentName: string, oController?:any): sap.ui.core.Fragment;
    //  Creates a JSON view of the given name and id.
    function jsonview(vView: any): sap.ui.core.mvc.View;
    function jsonview(sId: string, vView: any): sap.ui.core.mvc.View;
    //  Defines or creates an instance of a JavaScript view.
    function jsview(vView: any): sap.ui.core.mvc.JSView;
    function jsview(sId: string, vView: any): sap.ui.core.mvc.JSView;
    //  Creates a lazy loading stub for a given class sClassName.
    function lazyRequire(sClassName: string, sMethods?: string, sModuleName?: string): void;
    //  Redirects access to resources that are part of the given namespace to a location relative to the assumed application root folder.
    function localResources(sNamespace: string): any;
    //  Resolves one or more module dependencies.
    function require(vDependencies: any, fnCallback?: any): void;
    //  Returns the URL of a resource that belongs to the given library and has the given relative location within the library.
    function resource(sLibraryName: string, sResourcePath: string): void;
    //  Creates a Template for the given id, dom reference or a configuration object.
    function template(oTemplate?: any): any;
    //  Defines or creates an instance of a template view.
    function templateview(vView: any): sap.ui.core.mvc.TemplateView;
    function templateview(sId: string, vView: any): sap.ui.core.mvc.TemplateView;
    //  Creates a view of the given type, name and with the given id.
    function view(sId: string, vView?: any): sap.ui.core.mvc.View;
    //  Instantiates an XML-based Fragment.
    function xmlfragment(vFragment: any, oController?: any): sap.ui.core.Fragment;
    function xmlfragment(sId: string, vFragment: any, oController?: any): sap.ui.core.Fragment;
    //  Instantiates an XMLView of the given name and with the given id.
    function xmlview(vView: any): sap.ui.core.mvc.View;
    function xmlview(sId: string, vView: any): sap.ui.core.mvc.View;


    /**
     * Creates 0..n UI5 controls from an ExtensionPoint.One control if the ExtensionPoint is e.g. filled
     * with a View, zero for ExtensionPoints without configured extension andn controls for multi-root
     * Fragments as extension.In JSViews, this function allows both JSON notation in aggregation content as
     * well as adding an extension point to an aggregation after the target controlhas already been
     * instantiated. In the latter case the optional parameters oTargetControls and oTargetAggregation need
     * to be specified.
     * @param oContainer The view or fragment containing the extension point
     * @param sExtName The extensionName used to identify the extension point in the customizing
     * @param fnCreateDefaultContent Optional callback function creating default content, returning an
     * Array of controls. It is executed			when there's no customizing, if not provided, no default content
     * will be rendered.
     * @param oTargetControl Optional - use this parameter to attach the extension point to a particular
     * aggregation
     * @param sAggregationName Optional - if provided along with oTargetControl, the extension point
     * content is added to this particular aggregation at oTargetControl,			if not given, but an
     * oTargetControl is still present, the function will attempt to add the extension point to the default
     * aggregation of oTargetControl.			If no oTargetControl is provided, sAggregationName will also be
     * ignored.
     * @returns an array with 0..n controls created from an ExtensionPoint
    */
    function extensionpoint(oContainer: sap.ui.core.mvc.View | sap.ui.core.Fragment, sExtName: string, fnCreateDefaultContent?: any, oTargetControl?: sap.ui.core.Control, sAggregationName?: string): sap.ui.core.Control[];

    /**
     * Instantiate a Fragment - this method loads the Fragment content, instantiates it, and returns this
     * content.The Fragment object itself is not an entity which has further significance beyond this
     * constructor.To instantiate an existing Fragment, call this method as:   sap.ui.fragment(sName,
     * sType, [oController]);The sName must correspond to an XML Fragment which can be loadedvia the module
     * system (fragmentName + suffix ".fragment.[typeextension]") and which defines the Fragment content.If
     * oController is given, the (event handler) methods referenced in the Fragment will be called on this
     * controller.Note that Fragments may require a Controller to be given and certain methods to be
     * available.The Fragment types "XML", "JS" and "HTML" are available by default; additional Fragment
     * types can be implementedand added using the sap.ui.core.Fragment.registerType() function.Advanced
     * usage:To instantiate a Fragment and give further configuration options, call this method as:   
     * sap.ui.fragment(oFragmentConfig, [oController]);The oFragmentConfig object can have the following
     * properties:- "fragmentName": the name of the Fragment, as above- "fragmentContent": the definition
     * of the Fragment content itself. When this property is given, any given name is ignored.        The
     * type of this property depends on the Fragment type, e.g. it could be a string for XML Fragments.-
     * "type": the type of the Fragment, as above (mandatory)- "id": the ID of the Fragment
     * (optional)Further properties may be supported by future or custom Fragment types. Any given
     * propertieswill be forwarded to the Fragment implementation.If you want to give a fixed ID for the
     * Fragment, please use the advanced version of this method call with theconfiguration object or use
     * the typed factories like sap.ui.xmlfragment(...) or sap.ui.jsfragment(...).Otherwise the Fragment ID
     * is generated. In any case, the Fragment ID will be used as prefix for the ID ofall contained
     * controls.
     * @param sName the Fragment name
     * @param sType the Fragment type, e.g. "XML", "JS", or "HTML"
     * @param oController the Controller which should be used by the controls in the Fragment. Note that
     * some Fragments may not need a Controller and other may need one - and even rely on certain methods
     * implemented in the Controller.
     * @returns the root Control(s) of the Fragment content
    */
    function fragment(sName: string, sType: string, oController?: sap.ui.core.mvc.Controller): sap.ui.core.Control | sap.ui.core.Control[];

    /**
     * Retrieve the {@link sap.ui.core.Core SAPUI5 Core} instance for the current window.
     * @returns the API of the current SAPUI5 Core instance.
    */
    function getCore(): sap.ui.core.Core;

    /**
     * Loads the version info file (resources/sap-ui-version.json) and returnsit or if a library name is
     * specified then the version info of the individuallibrary will be returned.In case of the version
     * info file is not available an error will occur whencalling this function.
     * @param mOptions name of the library (e.g. "sap.ui.core") or a object map (see below)
     * @returns the full version info, the library specific one,                                  
     * undefined (if library is not listed or there was an error and "failOnError" is set to "false")      
     *                             or a Promise which resolves with one of them
    */
    function getVersionInfo(mOptions: string | any): any | any | JQueryPromise<any>;

    /**
     * Instantiates an HTML-based Fragment.To instantiate a Fragment, call this method as:  
     * sap.ui.htmlfragment([sId], sFragmentName, [oController]);The Fragment instance ID is optional
     * (generated if not given) and will be used as prefix for the ID of allcontained controls. The
     * sFragmentName must correspond to an HTML Fragment which can be loadedvia the module system
     * (fragmentName + ".fragment.html") and which defines the Fragment.If oController is given, the
     * methods referenced in the Fragment will be called on this controller.Note that Fragments may require
     * a Controller to be given and certain methods to be available.Advanced usage:To instantiate a
     * Fragment and optionally directly give the HTML definition instead of loading it from a file,call
     * this method as:    sap.ui.htmlfragment(oFragmentConfig, [oController]);The oFragmentConfig object
     * can have a either a "fragmentName" or a "fragmentContent" property.fragmentContent is optional and
     * can hold the Fragment definition as XML string; if notgiven, fragmentName must be given and the
     * Fragment content definition is loaded by the module system.Again, if oController is given, the
     * methods referenced in the Fragment will be called on this controller.
     * @param sId id of the newly created Fragment
     * @param vFragment name of the Fragment (or Fragment configuration as described above, in this case no
     * sId may be given. Instead give the id inside the config object, if desired.)
     * @param oController a Controller to be used for event handlers in the Fragment
     * @returns the root Control(s) of the created Fragment instance
    */
    function htmlfragment(sId: string, vFragment: string | any, oController?: sap.ui.core.mvc.Controller): sap.ui.core.Control | sap.ui.core.Control[];

    /**
     * Defines or creates an instance of a declarative HTML view.The behavior of this method depends on the
     * signature of the call and on the current context.<ul><li>View Definition <code>sap.ui.htmlview(sId,
     * vView)</code>: Defines a view of the given name with the givenimplementation. sId must be the views
     * name, vView must be an object and can containimplementations for any of the hooks provided by
     * HTMLView</li><li>View Instantiation <code>sap.ui.htmlview(sId?, vView)</code>: Creates an instance
     * of the view with the given name (and id)</li>.</ul>Any other call signature will lead to a runtime
     * error. If the id is omitted in the second variant, an id willbe created automatically.
     * @param sId id of the newly created view, only allowed for instance creation
     * @param vView name or implementation of the view.
     * @returns the created HTMLView instance in the creation case, otherwise undefined
    */
    function htmlview(sId: string, vView: string | any): sap.ui.core.mvc.HTMLView | any;

    /**
     * Defines OR instantiates an HTML-based Fragment.To define a JS Fragment, call this method as:  
     * sap.ui.jsfragment(sName, oFragmentDefinition)Where:- "sName" is the name by which this fragment can
     * be found and instantiated. If defined in its own file,   in order to be found by the module loading
     * system, the file location and name must correspond to sName   (path + file name must be:
     * fragmentName + ".fragment.js").- "oFragmentDefinition" is an object at least holding the
     * "createContent(oController)" method which defines   the Fragment content. If given during
     * instantiation, the createContent method receives a Controller   instance (otherwise oController is
     * undefined) and the return value must be one sap.ui.core.Control   (which could have any number of
     * children).To instantiate a JS Fragment, call this method as:   sap.ui.jsfragment([sId],
     * sFragmentName, [oController]);The Fragment ID is optional (generated if not given) and the Fragment
     * implementation CAN use itto make contained controls unique (this depends on the implementation: some
     * JS Fragments may choosenot to support multiple instances within one application and not use the ID
     * prefixing).The sFragmentName must correspond to a JS Fragment which can be loadedvia the module
     * system (fragmentName + ".fragment.js") and which defines the Fragment.If oController is given, the
     * methods referenced in the Fragment will be called on this controller.Note that Fragments may require
     * a Controller to be given and certain methods to be available.
     * @param sId id of the newly created Fragment
     * @param sFragmentName name of the Fragment (or Fragment configuration as described above, in this
     * case no sId may be given. Instead give the id inside the config object, if desired)
     * @param oController a Controller to be used for event handlers in the Fragment
     * @returns the root Control(s) of the created Fragment instance
    */
    function jsfragment(sId: string, sFragmentName: string | any, oController?: sap.ui.core.mvc.Controller): sap.ui.core.Control | sap.ui.core.Control[];

    /**
     * Creates a JSON view of the given name and id.The <code>viewName</code> must either correspond to a
     * JSON module that can be loadedvia the module system (viewName + suffix ".view.json") and which
     * defines the view or it mustbe a configuration object for a view.The configuration object can have a
     * viewName, viewContent and a controller property. The viewNamebehaves as described above, viewContent
     * can hold the view description as JSON string or as object literal.<strong>Note</strong>: when an
     * object literal is given, it might be modified during view construction.The controller property can
     * hold an controller instance. If a controller instance is given,it overrides the controller defined
     * in the view.Like with any other control, an id is optional and will be created when missing.
     * @param sId id of the newly created view
     * @param vView name of a view resource or view configuration as described above.
     * @returns the created JSONView instance
    */
    function jsonview(sId: string, vView: string | any): sap.ui.core.mvc.JSONView;

    /**
     * Defines or creates an instance of a JavaScript view.The behavior of this method depends on the
     * signature of the call and on the current context.<ul><li>View Definition <code>sap.ui.jsview(sId,
     * vView)</code>: Defines a view of the given name with the givenimplementation. sId must be the view's
     * name, vView must be an object and can containimplementations for any of the hooks provided by
     * JSView</li><li>View Instantiation <code>sap.ui.jsview(sId?, vView)</code>: Creates an instance of
     * the view with the given name (and id).If no view implementation has been defined for that view name,
     * a JavaScript module with the same name and with suffix "view.js" will be loadedand executed. The
     * module should contain a view definition (1st. variant above). </li></ul>Any other call signature
     * will lead to a runtime error. If the id is omitted in the second variant, an id willbe created
     * automatically.
     * @param sId id of the newly created view, only allowed for instance creation
     * @param vView name or implementation of the view.
     * @param bAsync defines how the view source is loaded and rendered later on (only relevant for
     * instantiation, ignored for everything else)
     * @returns the created JSView instance in the creation case, otherwise undefined
    */
    function jsview(sId: string, vView: string | any, bAsync?: boolean): sap.ui.core.mvc.JSView | any;

    /**
     * Creates a lazy loading stub for a given class <code>sClassName</code>.If the class has been loaded
     * already, nothing is done. Otherwise a stub objector constructor and - optionally - a set of stub
     * methods are created.All created stubs will load the corresponding module on executionand then
     * delegate to their counterpart in the loaded module.When no methods are given or when the list of
     * methods contains the special name"new" (which is an operator can't be used as method name in
     * JavaScript), then astub <b>constructor</b> for class <code>sClassName</code> is created.Otherwise, a
     * plain object is created.<b>Note</b>: Accessing any stub as a plain object without executing it (no
     * matterwhether it is a function or an object) won't load the module and therefore most likewon't work
     * as expected. This is a fundamental restriction of the lazy loader approach.It could only be fixed
     * with JavaScript 1.5 features that are not available in allUI5 target browsers (e.g. not in
     * IE8).<b>Note</b>: As a side effect of this method, the namespace containing the givenclass is
     * created <b>immediately</b>.
     * @param sClassName Fully qualified name (dot notation) of the class that should be prepared
     * @param sMethods space separated list of additional (static) methods that should be created as stubs
     * @param sModuleName name of the module to load, defaults to the class name
    */
    function lazyRequire(sClassName: string, sMethods?: string, sModuleName?: string): void;

    /**
     * Redirects access to resources that are part of the given namespace to a locationrelative to the
     * assumed <b>application root folder</b>.Any UI5 managed resource (view, controller, control,
     * JavaScript module, CSS file, etc.)whose resource name starts with <code>sNamespace</code>, will be
     * loaded from anequally named subfolder of the <b>application root folder</b>.If the resource name
     * consists of multiple segments (separated by a dot), each segmentis assumed to represent an
     * individual folder. In other words: when a resource name isconverted to an URL, any dots ('.') are
     * converted to slashes ('/').<b>Limitation:</b> For the time being, the <b>application root folder</b>
     * is assumed to bethe same as the folder where the current page resides in.Usage sample:<pre>  // Let
     * UI5 know that resources, whose name starts with "com.mycompany.myapp"  // should be loaded from the
     * URL location "./com/mycompany/myapp"  sap.ui.localResources("com.mycompany.myapp");  // The
     * following call implicitly will use the mapping done by the previous line  // It will load a view
     * from ./com/mycompany/myapp/views/Main.view.xml  sap.ui.view({ view :
     * "com.mycompany.myapp.views.Main", type : sap.ui.core.mvc.ViewType.XML});</pre>When applications need
     * a more flexible mapping between resource names and their location,they can use {@link
     * jQuery.sap.registerModulePath}.It is intended to make this configuration obsolete in future
     * releases, but for the timebeing, applications must call this method when they want to store
     * resources relative tothe assumed application root folder.
     * @param sNamespace Namespace prefix for which to load resources relative to the application root
     * folder
    */
    function localResources(sNamespace: string): void;

    /**
     * Ensures that a given a namespace or hierarchy of nested namespaces exists in thecurrent
     * <code>window</code>.
     * @param sNamespace undefined
     * @returns the innermost namespace of the hierarchy
    */
    function namespace(sNamespace: string): any;

    /**
     * Resolves one or more module dependencies.<b>Synchronous Retrieval of a Single Module Value</b>When
     * called with a single string, that string is assumed to be the name of an already loadedmodule and
     * the value of that module is returned. If the module has not been loaded yet,or if it is a Non-UI5
     * module (e.g. third party module), <code>undefined</code> is returned.This signature variant allows
     * synchronous access to module values without initiating module loading.Sample:<pre>  var JSONModel =
     * sap.ui.require("sap/ui/model/json/JSONModel");</pre>For modules that are known to be UI5 modules,
     * this signature variant can be used to check whetherthe module has been loaded.<b>Asynchronous
     * Loading of Multiple Modules</b>If an array of strings is given and (optionally) a callback function,
     * then the stringsare interpreted as module names and the corresponding modules (and their
     * transitivedependencies) are loaded. Then the callback function will be called asynchronously.The
     * module values of the specified modules will be provided as parameters to the callbackfunction in the
     * same order in which they appeared in the dependencies array.The return value for the asynchronous
     * use case is <code>undefined</code>.<pre>  sap.ui.require(['sap/ui/model/json/JSONModel',
     * 'sap/ui/core/UIComponent'], function(JSONModel,UIComponent) {    var MyComponent =
     * UIComponent.extend('MyComponent', {      ...    });    ...  });</pre>This method uses the same
     * variation of the {@link jQuery.sap.getResourcePath unified resource name}syntax that {@link
     * sap.ui.define} uses: module names are specified without the implicit extension '.js'.Relative module
     * names are not supported.
     * @param vDependencies dependency (dependencies) to resolve
     * @param fnCallback callback function to execute after resolving an array of dependencies
     * @returns a single module value or undefined
    */
    function require(vDependencies: string | string[], fnCallback?: any): any | any;

    /**
     * Returns the URL of a resource that belongs to the given library and has the given relative location
     * within the library.This is mainly meant for static resources like images that are inside the
     * library.It is NOT meant for access to JavaScript modules or anything for which a different URL has
     * been registered with jQuery.sap.registerModulePath(). Forthese cases use
     * jQuery.sap.getModulePath().It DOES work, however, when the given sResourcePath starts with "themes/"
     * (= when it is a theme-dependent resource). Even when for this theme a differentlocation outside the
     * normal library location is configured.
     * @param sLibraryName the name of a library, like "sap.ui.commons"
     * @param sResourcePath the relative path of a resource inside this library, like "img/mypic.png" or
     * "themes/my_theme/img/mypic.png"
     * @returns the URL of the requested resource
    */
    function resource(sLibraryName: string, sResourcePath: string): string;

    /**
     * Displays the control tree with the given root inside the area of the givenDOM reference (or inside
     * the DOM node with the given ID) or in the given Control.Example:<pre>  &lt;div
     * id="SAPUI5UiArea">&lt;/div>  &lt;script type="text/javascript">    var oRoot = new
     * sap.ui.commons.Label();    oRoot.setText("Hello world!");    sap.ui.setRoot("SAPUI5UiArea", oRoot); 
     * &lt;/script></pre><p>This is a shortcut for <code>sap.ui.getCore().setRoot()</code>.Internally, if a
     * string is given that does not identify an UIArea or a controlthen implicitly a new
     * <code>UIArea</code> is created for the given DOM referenceand the given control is added.
     * @param oDomRef a DOM Element or Id String of the UIArea
     * @param oControl the Control that should be added to the <code>UIArea</code>.
    */
    function setRoot(oDomRef: string | sap.ui.core.Element | sap.ui.core.Control, oControl: sap.ui.base.Interface | sap.ui.core.Control): void;

    /**
     * Creates a Template for the given id, dom reference or a configuration object.If no parameter is
     * defined this function makes a lookup of DOM elementswhich are specifying a type attribute. If the
     * value of this type attributematches an registered type then the content of this DOM element will
     * beused to create a new <code>Template</code> instance.If you want to lookup all kind of existing and
     * known templates and parse themdirectly you can simply call:<pre>  sap.ui.template();</pre>To parse a
     * concrete DOM element you can do so by using this function in thefollowing way:<pre> 
     * sap.ui.template("theTemplateId");</pre>Or you can pass the reference to a DOM element and use this
     * DOM element asa source for the template:<pre>  sap.ui.template(oDomRef);</pre>The last option to use
     * this function is to pass the information via aconfiguration object. This configuration object can be
     * used to pass acontext for the templating framework when compiling the template:<pre>  var
     * oTemplateById = sap.ui.template({    id: "theTemplateId",    context: { ... }  });  var
     * oTemplateByDomRef = sap.ui.template({    domref: oDomRef,    context: { ... }  });</pre>It can also
     * be used to load a template from another file:<pre>  var oTemplate = sap.ui.template({    id:
     * "myTemplate",    src: "myTemplate.tmpl"  });  var oTemplateWithContext = sap.ui.template({    id:
     * "myTemplate",    src: "myTemplate.tmpl",    context: { ... }  });</pre>The properties of the
     * configuration object are the following:<ul><li><code>id</code> - the ID of the Template / the ID  of
     * the DOM element containing the source of the Template</li><li><code>domref</code> - the DOM element
     * containing the source of the Template</li><li><code>type</code> - the type of the
     * Template</li><li><code>src</code> - the URL to lookup the template</li>
     * (<i>experimental!</i>)<li><code>control</code> - the fully qualified name of the control to
     * declare</li> (<i>experimental!</i>)</ul>
     * @param oTemplate the id or the DOM reference to the template to lookup or an configuration object
     * containing the src, type and eventually the id of the Template.
     * @returns the created Template instance        or in case of usage without parametes any array of
     * templates is returned
    */
    function template(oTemplate: string | any | any): any | any[];

    /**
     * Defines or creates an instance of a template view.The behavior of this method depends on the
     * signature of the call and on the current context.<ul><li>View Definition
     * <code>sap.ui.templateview(sId, vView)</code>: Defines a view of the given name with the
     * givenimplementation. sId must be the views name, vView must be an object and can
     * containimplementations for any of the hooks provided by templateview</li><li>View Instantiation
     * <code>sap.ui.templateview(sId?, vView)</code>: Creates an instance of the view with the given name
     * (and id)</li>.</ul>Any other call signature will lead to a runtime error. If the id is omitted in
     * the second variant, an id willbe created automatically.
     * @param sId id of the newly created view, only allowed for instance creation
     * @param vView name or implementation of the view.
     * @returns the created TemplateView instance in the creation case, otherwise undefined
    */
    function templateview(sId: string, vView: string | any): sap.ui.core.mvc.TemplateView | any;

    /**
     * Creates a view of the given type, name and with the given id.The <code>vView</code> configuration
     * object can have the following properties for the viewinstantiation:<ul><li>The ID
     * <code>vView.id</code> specifies an ID for the View instance. If no ID is given,an ID will be
     * generated.</li><li>The view name <code>vView.viewName</code> corresponds to an XML module that can
     * be loadedvia the module system (vView.viewName + suffix ".view.xml")</li><li>The controller instance
     * <code>vView.controller</code> must be a valid controller implementation.The given controller
     * instance overrides the controller defined in the view definition</li><li>The view type
     * <code>vView.type</code> specifies what kind of view will be instantiated. All validview types are
     * listed in the enumeration sap.ui.core.mvc.ViewType.</li><li>The view data
     * <code>vView.viewData</code> can hold user specific data. This data is availableduring the whole
     * lifecycle of the view and the controller</li><li>The view loading mode <code>vView.async</code> must
     * be a boolean and defines if the view source is loadedsynchronously or asynchronously. In async mode,
     * the view is rendered empty initially, and rerenderd with theloaded view
     * content.</li><li><code>vView.preprocessors</code></li> can hold a map from the specified
     * preprocessor type (e.g. "xml") to an array ofpreprocessor configurations; each configuration
     * consists of a <code>preprocessor</code> property (optional whenregistered as on-demand preprocessor)
     * and may contain further preprocessor-specific settings. The preprocessor canbe either a module name
     * as string implementation of {@link sap.ui.core.mvc.View.Preprocessor} or a function according
     * to{@link sap.ui.core.mvc.View.Preprocessor.process}. Do not set properties starting with underscore
     * like <code>_sProperty</code>property, these are reserved for internal purposes. When several
     * preprocessors are provided for one hook, it has to be madesure that they do not conflict when beeing
     * processed serially.<strong>Note</strong>: These preprocessors are only available to this instance.
     * For global oron-demand availability use {@link
     * sap.ui.core.mvc.XMLView.registerPreprocessor}.<strong>Note</strong>: Please note that preprocessors
     * in general are currently only availableto XMLViews.<strong>Note</strong>: Preprocessors only work in
     * async views and will be ignored when the view is instantiatedin sync mode by default, as this could
     * have unexpected side effects. You may override this behaviour by setting thebSyncSupport flag of the
     * preprocessor to true.
     * @param sId id of the newly created view, only allowed for instance creation
     * @param vView the view name or view configuration object
     * @returns the created View instance
    */
    function view(sId: string, vView?: string | any): sap.ui.core.mvc.View;

    /**
     * Instantiates an XML-based Fragment.To instantiate a Fragment, call this method as:  
     * sap.ui.xmlfragment([sId], sFragmentName, [oController]);The Fragment instance ID is optional
     * (generated if not given) and will be used as prefix for the ID of allcontained controls. The
     * sFragmentName must correspond to an XML Fragment which can be loadedvia the module system
     * (fragmentName + ".fragment.xml") and which defines the Fragment.If oController is given, the methods
     * referenced in the Fragment will be called on this controller.Note that Fragments may require a
     * Controller to be given and certain methods to be available.Advanced usage:To instantiate a Fragment
     * and optionally directly give the XML definition instead of loading it from a file,call this method
     * as:    sap.ui.xmlfragment(oFragmentConfig, [oController]);The oFragmentConfig object can have a
     * either a "fragmentName" or a "fragmentContent" property.fragmentContent is optional and can hold the
     * Fragment definition as XML string; if notgiven, fragmentName must be given and the Fragment content
     * definition is loaded by the module system.Again, if oController is given, the methods referenced in
     * the Fragment will be called on this controller.
     * @param sId id of the newly created Fragment
     * @param vFragment name of the Fragment (or Fragment configuration as described above, in this case no
     * sId may be given. Instead give the id inside the config object, if desired)
     * @param oController a Controller to be used for event handlers in the Fragment
     * @returns the root Control(s) of the created Fragment instance
    */
    function xmlfragment(sId: string, vFragment: string | any, oController?: sap.ui.core.mvc.Controller): sap.ui.core.Control | sap.ui.core.Control[];

    /**
     * Instantiates an XMLView of the given name and with the given ID.The <code>viewName</code> must
     * either correspond to an XML module that can be loadedvia the module system (viewName + suffix
     * ".view.xml") and which defines the view, or it mustbe a configuration object for a view.The
     * configuration object can have a <code>viewName</code>, <code>viewContent</code> and a
     * <code>controller</code> property. The <code>viewName</code> behaves as described above.
     * <code>viewContent</code> is optionaland can hold a view description as XML string or as already
     * parsed XML Document. If not given, the view content definition is loaded by the module
     * system.<strong>Note</strong>: if a <code>Document</code> is given, it might be modified during view
     * construction.<strong>Note</strong>: if you enable caching, you need to take care of the invalidation
     * via keys. Automaticinvalidation takes only place if the UI5 version or the component descriptor
     * (manifest.json) change. This isstill an experimental feature and may experience slight changes of
     * the invalidation parameters or the cachekey format.The controller property can hold an controller
     * instance. If a controller instance is given,it overrides the controller defined in the view.Like
     * with any other control, ID is optional and one will be created automatically.
     * @param sId ID of the newly created view
     * @param vView Name of the view or a view configuration object as described above
     * @param  undefined
     * @returns the created XMLView instance
    */
    function xmlview(sId: string, vView: string | any, param: any): sap.ui.core.mvc.XMLView;
    namespace app {
      /**
       * Class to mock a server
       * @resource sap/ui/app/MockServer.js
      */
      export abstract class MockServer extends sap.ui.base.ManagedObject {


        /**
         * Creates a mocked server. This helps to mock all or some backend calls, e.g. for OData/JSON Models or
         * simple XHR calls, withoutchanging the application code. This class can also be used for qunit tests.
         * @param sId id for the new server object; generated automatically if no non-empty id is given    
         * Note: this can be omitted, no matter whether <code>mSettings</code> will be given or not!
         * @param mSettings optional map/JSON-object with initial property values, aggregated objects etc. for
         * the new object
         * @param oScope scope object for resolving string based type and formatter references in bindings
        */
        constructor(sId: string, mSettings?: any, oScope?: any);


      }
      /**
       * Base class for application classes
       * @resource sap/ui/app/Application.js
      */
      export abstract class Application extends sap.ui.core.Component {


        /**
         * Abstract application class. Extend this class to create a central application class.Only one
         * instance is allowed.Accepts an object literal <code>mSettings</code> that defines initialproperty
         * values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId optional id for the application; generated automatically if           no non-empty id is
         * given Note: this can be omitted, no matter           whether <code>mSettings</code> will be given or
         * not!
         * @param mSettings optional map/JSON-object with initial settings for the           new application
         * instance
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Creates and returns the root component. Override this method in your application implementation, if
         * you want to override the default creation by metadata.
         * @returns the root component
        */
        createRootComponent(): sap.ui.core.UIComponent;

        /**
        */
        destroy(bSuppressInvalidate: boolean): void;

        /**
         * Destroys the rootComponent in the aggregation <code>rootComponent</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyRootComponent(): any;


        /**
         * Gets current value of property <code>config</code>.
         * @returns Value of property <code>config</code>
        */
        getConfig(): any;

        /**
         * Returns a metadata object for class sap.ui.app.Application.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>root</code>.
         * @returns Value of property <code>root</code>
        */
        getRoot(): string;

        /**
         * Gets content of aggregation <code>rootComponent</code>.
        */
        getRootComponent(): sap.ui.core.UIComponent;

        /**
         * Returns the application root component.
         * @since 1.13.1
         * @returns The root component
        */
        getView(): sap.ui.core.Control;

        /**
         * The main method is called when the DOM and UI5 is completely loaded. Override this method in your
         * Application class implementation to execute code which relies on a loaded DOM / UI5.
        */
        main(): void;

        /**
         * On before exit application hook. Override this method in your Application class implementation, to
         * handle cleanup before the real exit or to prompt a question to the user,if the application should be
         * exited.
         * @returns return a string if a prompt should be displayed to the user confirming closing the
         * application (e.g. when the application is not yet saved).
        */
        onBeforeExit(): string;

        /**
         * On error hook. Override this method in your Application class implementation to listen to unhandled
         * errors.
         * @param sMessage The error message.
         * @param sFile The file where the error occurred
         * @param iLine The line number of the error
        */
        onError(sMessage: string, sFile: string, iLine: number): void;

        /**
         * On exit application hook. Override this method in your Application class implementation, to handle
         * cleanup of the application.
        */
        onExit(): void;

        /**
         * Sets the configuration model.
         * @since 1.13.1
         * @param vConfig the configuration model, the configuration object or a URI string to load a JSON
         * configuration file.
        */
        setConfig(vConfig: string | any | sap.ui.model.Model): void;

        /**
         * Sets a new value for property <code>root</code>.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.
         * @param sRoot New value for property <code>root</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setRoot(sRoot: string): any;

        /**
         * Sets the aggregated <code>rootComponent</code>.
         * @param oRootComponent The rootComponent to set
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setRootComponent(oRootComponent: sap.ui.core.UIComponent): any;
      }
    }
    namespace test {
      namespace gherkin {
        namespace dataTableUtils {

          /**
           * Takes the inputed 2D list 'aData' and returns an equivalent object. Each row of data is expected
           * tobe a property-value pair. To create nested objects, add extra columns to the data. E.g.<pre> [  
           * ['Name', 'Alice'],   ['Mass', '135 lbs'],   ['Telephone Number', 'Home', '123-456-7890'],  
           * ['Telephone Number', 'Work', '123-456-0987'] ]</pre>For each data row, the right-most element
           * becomes a property value, and everything else is a propertyname. The property names get normalized
           * according to the strategy defined by the parameter 'oNorm'.E.g. using camelCase strategy<pre>  {   
           * name: 'Alice',    mass: '135 lbs',    telephoneNumber: {      home: '123-456-7890',      work:
           * '123-456-0987'    }  }</pre>
           * @param aData the input data to be converted
           * @param oNorm the normalization function to use to normalize property                                
           *             names. Can also be a string with values 'titleCase', 'pascalCase',                      
           *                       'camelCase', 'hyphenated' or 'none'.
           * @returns - an object equivalent to the input data, with property names normalized
          */
          function toObject(aData: string[][], oNorm?: string | any): any;

          /**
           * Takes the inputed 2D list 'aData' and returns an equivalent list of objects. The data is expected
           * tohave a header row, with each subsequent row being an entity, and each column being a property of
           * thatentity. E.g.<pre>  [    ["Their Name",  "Their Age"],    ["Alice",       "16"],    ["Bob",      
           *   "22"]  ]</pre>The data's column headers become the returned objects' property names. The property
           * names get normalizedaccording to the strategy defined by the parameter 'oNorm'. E.g. using
           * hyphenation strategy this is returned:<pre>  [    {their-name: "Alice", their-age: "16"},   
           * {their-name: "Bob", their-age: "22"}  ]</pre>
           * @param aData the input data to be converted, with a header row
           * @param oNorm the normalization function to use to normalize property                                
           *             names. Can also be a String with values 'titleCase', 'pascalCase',                      
           *                       'camelCase', 'hyphenated' or 'none'.
           * @returns - a list of objects equivalent to the input data, with property names normalized
          */
          function toTable(aData: string[][], oNorm?: string | any): any[];
          namespace normalization {

            /**
             * e.g. "First Name" -> "firstName"
             * @param sString the string to normalize
             * @returns the input string with all words after the first capitalized and all spaces removed
            */
            function camelCase(sString: string): string;

            /**
             * e.g. "First Name" -> "first-name"
             * @param sString the string to normalize
             * @returns the input string trimmed, changed to lower case and with space between words               
             *   replaced by a hyphen ('-')
            */
            function hyphenated(sString: string): string;

            /**
             * e.g. "First Name" -> "First Name"
             * @param sString the string to normalize
             * @returns the original unchanged input string
            */
            function none(sString: string): string;

            /**
             * e.g. "first name" -> "FirstName"
             * @param sString the string to normalize
             * @returns the input string with all words capitalized and all spaces removed
            */
            function pascalCase(sString: string): string;

            /**
             * e.g. "first name" -> "First Name"
             * @param sString the string to normalize
             * @returns the input string trimmed and with all words capitalized
            */
            function titleCase(sString: string): string;
          }
        }
        namespace opa5TestHarness {

          /**
           * Dynamically generates Opa5 testsIf a test step is missing and args.generateMissingSteps is true then
           * the  Gherkin step will be converted into OpaPage Object code and executed. The text will be
           * converted to camelCase and have any non-alphanumeric characterremoved. Here are two pertinent
           * examples:(1) The simple step "Given I start my app" will be converted into the call
           * "Given.iStartMyApp();"(2) The step "Then on page 1: I should see the page 1 text" will become the
           * call    "Then.onPage1.iShouldSeeThePage1Text();"Chaining function calls, such as
           * "Then.iStartMyApp().and.iCloseMyApp()" is not possible at this time.
           * @param args the arguments to the function
          */
          function test(args: any): void;
        }
        namespace qUnitTestHarness {

          /**
           * Dynamically generates and executes QUnit tests
           * @param args the arguments to the function
          */
          function test(args: any): void;
        }
        /**
         * @resource sap/ui/test/gherkin/StepDefinitions.js
        */
        export abstract class StepDefinitions extends sap.ui.base.Object {


          /**
           * A Gherkin feature file is human-readable, and the computer does not know how to execute its steps.
           * ThisStepDefinitions class provides the interface between human and machine. It defines what each
           * step in the Gherkinfeature file will actually do when it is executed.Meant to be
           * implemented/overridden by a child object. Specifically, the functions 'init' and
           * 'closeApplication'need to be overridden.
          */
          constructor();



          /**
           * Closes the application and cleans up any mess made by the tests. To avoid erroneous exceptions
           * during testexecution, make sure that it is safe to run this method even if the application was never
           * started.
          */
          closeApplication(): void;


          /**
           * Returns a metadata object for class sap.ui.test.gherkin.StepDefinitions.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Registers the step definitions by calling the method 'register'. The order of the register calls is
           * important.The first step definition whose regular expression matches the step text is the one that
           * will be executed,however, the step definitions are checked in REVERSE ORDER (i.e. the last one you
           * wrote is checked first).
          */
          init(): void;

          /**
           * Registers a step definition.
           * @param rRegex the regular expression that matches the feature file step (with leading 'Given',
           * 'When',                         'Then' or 'But' removed). E.g. if the feature file has the step     
           *                    "Then I should be served a coffee" it will truncated to "I should be served a
           * coffee"                         and tested against 'rRegex' to check for a match. The simple regular
           * expression                         /^I should be served a coffee$/i would match this text. The
           * regular                         expression can specify capturing groups, which will be passed as
           * parameters to 'fnFunc'.
           * @param fnFunc the function to execute in the event that the regular expression matches. Receives    
           *                       regular expression capturing groups as parameters in the same order that they
           * are                           specified in the regular expression. If a data table is specified for
           * the step, it                           will be passed as an additional final parameter. At execution
           * time, all functions                           within a particular scenario will execute within the
           * same 'this' context.
          */
          register(rRegex: RegExp, fnFunc: any): void;
        }
      }
      namespace actions {
        /**
         * @resource sap/ui/test/actions/Press.js
        */
        export class Press extends sap.ui.test.actions.Action {

          /**
           * A map that contains the id suffixes for certain controls of the library.When you extended a UI5
           * controls the adapter of the control will be taken.If you need an adapter for your own control you
           * can add it here. For example:You wrote a control with the namespace my.Control it renders two
           * buttons and you want the press action to press the second one by default.<pre><code>    new
           * my.Control("myId");</code></pre>It contains two button tags in its dom.When you render your control
           * it creates the following dom:<pre><code>    <div id="myId">        <button id="myId-firstButton"/>  
           *      <button id="myId-secondButton"/>    </div></code></pre>Then you may add a control adapter like
           * this<pre><code>    Press.controlAdapters["my.control"] = "secondButton" //This can be used by
           * setting the Target Property of an action    // Example usage    new Press(); // executes on second
           * Button since it is set as default    new Press({ idSuffix: "firstButton"}); // executes on the first
           * button has to be the same as the last part of the id in the dom</code></pre>
          */
          public controlAdapters: any;


          /**
           * The Press action is used to simulate a press interaction on a Control's dom ref.This will work out
           * of the box for most of the controls (even custom controls).Here is a List of supported controls
           * (some controls will trigger the press on a specific region):<ul>    <li>sap.m.Button</li>   
           * <li>sap.m.Link</li>    <li>sap.m.StandardListItem</li>    <li>sap.m.IconTabFilter</li>   
           * <li>sap.m.SearchField - Search Button</li>    <li>sap.m.Page - Back Button</li>   
           * <li>sap.m.semantic.FullscreenPage - Back Button</li>    <li>sap.m.semantic.DetailPage - Back
           * Button</li>    <li>sap.m.List - More Button</li>    <li>sap.m.Table - More Button</li>   
           * <li>sap.m.StandardTile</li></ul>
          */
          constructor();



          /**
           * Sets focus on given control and triggers a 'tap' event on it (which isinternally translated into a
           * 'press' event).Logs an error if control is not visible (i.e. has no dom representation)
           * @param oControl the control on which the 'press' event is triggered
          */
          executeOn(oControl: sap.ui.core.Control): void;


          /**
           * Returns a metadata object for class sap.ui.test.actions.Press.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;
        }
        /**
         * Actions for Opa5 - needs to implement an executeOn function that should simulate a user interaction
         * on a control
         * @resource sap/ui/test/actions/Action.js
        */
        export abstract class Action extends sap.ui.base.ManagedObject {


          /**
           * Accepts an object literal <code>mSettings</code> that defines initialproperty values, aggregated and
           * associated objects as well as event handlers.See {@link sap.ui.base.ManagedObject#constructor} for a
           * general description of the syntax of the settings object.
          */
          constructor();



          /**
           * Checks if the matcher is matching - will get an instance of sap.ui.Control as parameterShould be
           * overwritten by subclasses
           * @param element the {@link sap.ui.core.Element} or a control (extends element) the action will be
           * executed on
          */
          executeOn(element: sap.ui.core.Control): void;


          /**
           * Gets current value of property <code>idSuffix</code>.
           * @since 1.38
           * @returns Value of property <code>idSuffix</code>
          */
          getIdSuffix(): string;

          /**
           * Returns a metadata object for class sap.ui.test.actions.Action.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Sets a new value for property <code>idSuffix</code>.When called with a value of <code>null</code> or
           * <code>undefined</code>, the default value of the property will be restored.
           * @since 1.38
           * @param sIdSuffix New value for property <code>idSuffix</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setIdSuffix(sIdSuffix: string): sap.ui.test.actions.Action;
        }
        /**
         * @resource sap/ui/test/actions/EnterText.js
        */
        export class EnterText extends sap.ui.test.actions.Action {


          /**
           * The EnterText action is used to simulate a user entering texts to inputs.EnterText will be executed
           * on a control's focus dom ref.Supported controls are (for other controls this action still might
           * work):<ul>    <li>sap.m.Input</li>    <li>sap.m.SearchField</li>   
           * <li>sap.m.TextArea</li></ul>Accepts an object literal <code>mSettings</code> that defines
           * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
           * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
           * object.
          */
          constructor();



          /**
           * Sets focus on given control and triggers Multiple keyboard events on it, one event for every
           * character in the text.Logs an error if control has no focusable dom ref or is not visible.
           * @param oControl the control on which the text event should be entered in.
          */
          executeOn(oControl: sap.ui.core.Control): void;


          /**
           * Gets current value of property <code>clearTextFirst</code>.Default value is <code>true</code>.
           * @since 1.38.0
           * @returns Value of property <code>clearTextFirst</code>
          */
          getClearTextFirst(): boolean;

          /**
           * Returns a metadata object for class sap.ui.test.actions.EnterText.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Gets current value of property <code>text</code>.The Text that is going to be typed to the control.
           * If you are entering an empty string, the value will be cleared.
           * @returns Value of property <code>text</code>
          */
          getText(): string;

          /**
           * Sets a new value for property <code>clearTextFirst</code>.When called with a value of
           * <code>null</code> or <code>undefined</code>, the default value of the property will be
           * restored.Default value is <code>true</code>.
           * @since 1.38.0
           * @param bClearTextFirst New value for property <code>clearTextFirst</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setClearTextFirst(bClearTextFirst: boolean): sap.ui.test.actions.EnterText;

          /**
           * Sets a new value for property <code>text</code>.The Text that is going to be typed to the control.
           * If you are entering an empty string, the value will be cleared.When called with a value of
           * <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
           * @param sText New value for property <code>text</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setText(sText: string): sap.ui.test.actions.EnterText;
        }
      }
      namespace matchers {
        /**
         * Matchers for Opa5 - needs to implement an isMatching function that returns a boolean and will get a
         * control instance as parameter
         * @resource sap/ui/test/matchers/Matcher.js
        */
        export abstract class Matcher extends sap.ui.base.ManagedObject {


          constructor();




          /**
           * Returns a metadata object for class sap.ui.test.matchers.Matcher.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Checks if the matcher is matching - will get an instance of sap.ui.Control as parameter.Should be
           * overwritten by subclasses
           * @param oControl the control that is checked by the matcher
           * @returns true if the Control is matching the condition of the matcher
          */
          isMatching(oControl: sap.ui.core.Control): boolean;
        }
        /**
         * Ancestor - checks if a control has a defined ancestor
         * @resource sap/ui/test/matchers/Ancestor.js
        */
        export class Ancestor {


          constructor(oAncestorControl: any, bDirect?: boolean);


        }
        /**
         * Properties - checks if a control's properties have the provided values - all properties have to
         * match their values.
         * @resource sap/ui/test/matchers/Properties.js
        */
        export class Properties {


          constructor(oProperties: any);


        }
        /**
         * BindingPath - checks if a control has a binding context with the exact same binding path
         * @resource sap/ui/test/matchers/BindingPath.js
        */
        export class BindingPath extends sap.ui.test.matchers.Matcher {


          /**
           * BindingPath - checks if a control has a binding context with the exact same binding path.Accepts an
           * object literal <code>mSettings</code> that defines initialproperty values, aggregated and associated
           * objects as well as event handlers.See {@link sap.ui.base.ManagedObject#constructor} for a general
           * description of the syntax of the settings object.
           * @param mSettings Map/JSON-object with initial settings for the new BindingPath.
          */
          constructor(mSettings: any);




          /**
           * Returns a metadata object for class sap.ui.test.matchers.BindingPath.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Gets current value of property <code>modelName</code>.The name of the binding model that is used for
           * matching.
           * @returns Value of property <code>modelName</code>
          */
          getModelName(): string;

          /**
           * Gets current value of property <code>path</code>.The value of the binding path that is used for
           * matching.
           * @returns Value of property <code>path</code>
          */
          getPath(): string;

          /**
           * Checks if the control has a binding context that matches the path
           * @param oControl the control that is checked by the matcher
           * @returns true if the binding path has a strictly matching value.
          */
          isMatching(oControl: sap.ui.core.Control): boolean;

          /**
           * Sets a new value for property <code>modelName</code>.The name of the binding model that is used for
           * matching.When called with a value of <code>null</code> or <code>undefined</code>, the default value
           * of the property will be restored.
           * @param sModelName New value for property <code>modelName</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setModelName(sModelName: string): sap.ui.test.matchers.BindingPath;

          /**
           * Sets a new value for property <code>path</code>.The value of the binding path that is used for
           * matching.When called with a value of <code>null</code> or <code>undefined</code>, the default value
           * of the property will be restored.
           * @param sPath New value for property <code>path</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setPath(sPath: string): sap.ui.test.matchers.BindingPath;
        }
        /**
         * Interactable - check if a control is currently able to take user interactions.OPA5 will
         * automatically apply this matcher if you specify actions in {@link sap.ui.test.Opa5#waitFor}.A
         * control will be filtered out by this matcher when:<ul>    <li>        There are unfinished
         * XMLHttpRequests (globally).        That means, the Opa can wait for pending requests to finish that
         * would probably update the UI.        Also detects sinon.FakeXMLHttpRequests that are not responded
         * yet.    </li>    <li>        The control is invisible (using the visible matcher)    </li>    <li>  
         *      The control is hidden behind a dialog    </li>    <li>        The control is in a navigating
         * nav container    </li>    <li>        The control or its parents are busy    </li>    <li>       
         * The control or its parents are not enabled    </li>    <li>        The UIArea of the control needs
         * new rendering    </li></ul>
         * @resource sap/ui/test/matchers/Interactable.js
        */
        export class Interactable extends sap.ui.test.matchers.Matcher {


          constructor();




          /**
           * Returns a metadata object for class sap.ui.test.matchers.Interactable.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;
        }
        /**
         * AggregationFilled - checks if an aggregation contains at least one entry
         * @resource sap/ui/test/matchers/AggregationFilled.js
        */
        export class AggregationFilled extends sap.ui.test.matchers.Matcher {


          /**
           * AggregationFilled - checks if an aggregation contains at least one entry.Accepts an object literal
           * <code>mSettings</code> that defines initialproperty values, aggregated and associated objects as
           * well as event handlers.See {@link sap.ui.base.ManagedObject#constructor} for a general description
           * of the syntax of the settings object.
           * @param mSettings optional map/JSON-object with initial settings for the new AggregationFilledMatcher
          */
          constructor(mSettings: any);




          /**
           * Returns a metadata object for class sap.ui.test.matchers.AggregationFilled.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Gets current value of property <code>name</code>.The name of the aggregation that is used for
           * matching.
           * @returns Value of property <code>name</code>
          */
          getName(): string;

          /**
           * Checks if the control has a filled aggregation.
           * @param oControl the control that is checked by the matcher
           * @returns true if the Aggregation set in the property aggregationName is filled, false if it is not.
          */
          isMatching(oControl: sap.ui.core.Control): boolean;

          /**
           * Sets a new value for property <code>name</code>.The name of the aggregation that is used for
           * matching.When called with a value of <code>null</code> or <code>undefined</code>, the default value
           * of the property will be restored.
           * @param sName New value for property <code>name</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setName(sName: string): sap.ui.test.matchers.AggregationFilled;
        }
        /**
         * PropertyStrictEquals - checks if a property has the exact same value
         * @resource sap/ui/test/matchers/PropertyStrictEquals.js
        */
        export class PropertyStrictEquals extends sap.ui.test.matchers.Matcher {


          /**
           * PropertyStrictEquals - checks if a property has the exact same value.Accepts an object literal
           * <code>mSettings</code> that defines initialproperty values, aggregated and associated objects as
           * well as event handlers.See {@link sap.ui.base.ManagedObject#constructor} for a general description
           * of the syntax of the settings object.
           * @param mSettings optional map/JSON-object with initial settings for the new PropertyStrictEquals
          */
          constructor(mSettings: any);




          /**
           * Returns a metadata object for class sap.ui.test.matchers.PropertyStrictEquals.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Gets current value of property <code>name</code>.The Name of the property that is used for matching.
           * @returns Value of property <code>name</code>
          */
          getName(): string;

          /**
           * Gets current value of property <code>value</code>.The value of the property that is used for
           * matching.
           * @returns Value of property <code>value</code>
          */
          getValue(): any;

          /**
           * Checks if the control has a property that matches the value
           * @param oControl the control that is checked by the matcher
           * @returns true if the property has a strictly matching value.
          */
          isMatching(oControl: sap.ui.core.Control): boolean;

          /**
           * Sets a new value for property <code>name</code>.The Name of the property that is used for
           * matching.When called with a value of <code>null</code> or <code>undefined</code>, the default value
           * of the property will be restored.
           * @param sName New value for property <code>name</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setName(sName: string): sap.ui.test.matchers.PropertyStrictEquals;

          /**
           * Sets a new value for property <code>value</code>.The value of the property that is used for
           * matching.When called with a value of <code>null</code> or <code>undefined</code>, the default value
           * of the property will be restored.
           * @param oValue New value for property <code>value</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setValue(oValue: any): sap.ui.test.matchers.PropertyStrictEquals;
        }
        /**
         * AggregationLengthEquals - checks if an aggregation contains at least one entry
         * @resource sap/ui/test/matchers/AggregationLengthEquals.js
        */
        export class AggregationLengthEquals extends sap.ui.test.matchers.Matcher {


          /**
           * AggregationLengthEquals - checks if an aggregation contains at least one entry.Accepts an object
           * literal <code>mSettings</code> that defines initialproperty values, aggregated and associated
           * objects as well as event handlers.See {@link sap.ui.base.ManagedObject#constructor} for a general
           * description of the syntax of the settings object.
           * @param mSettings optional map/JSON-object with initial settings for the new
           * AggregationLengthEqualsMatcher
          */
          constructor(mSettings: any);




          /**
           * Gets current value of property <code>length</code>.The length that aggregation <code>name</code>
           * should have.
           * @returns Value of property <code>length</code>
          */
          getLength(): number;

          /**
           * Returns a metadata object for class sap.ui.test.matchers.AggregationLengthEquals.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Gets current value of property <code>name</code>.The name of the aggregation that is used for
           * matching.
           * @returns Value of property <code>name</code>
          */
          getName(): string;

          /**
           * Checks if the control's aggregation <code>name</code> has length <code>length</code>.
           * @param oControl the control that is checked by the matcher
           * @returns true if the length of aggregation <code>name</code> is the same as <code>length</code>,
           * false if it is not.
          */
          isMatching(oControl: sap.ui.core.Control): boolean;

          /**
           * Sets a new value for property <code>length</code>.The length that aggregation <code>name</code>
           * should have.When called with a value of <code>null</code> or <code>undefined</code>, the default
           * value of the property will be restored.
           * @param iLength New value for property <code>length</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setLength(iLength: number): sap.ui.test.matchers.AggregationLengthEquals;

          /**
           * Sets a new value for property <code>name</code>.The name of the aggregation that is used for
           * matching.When called with a value of <code>null</code> or <code>undefined</code>, the default value
           * of the property will be restored.
           * @param sName New value for property <code>name</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setName(sName: string): sap.ui.test.matchers.AggregationLengthEquals;
        }
        /**
         * AggregationContainsPropertyEqual - checks if an aggregation contains at least one item that has a
         * Property set to a certain value
         * @resource sap/ui/test/matchers/AggregationContainsPropertyEqual.js
        */
        export class AggregationContainsPropertyEqual extends sap.ui.test.matchers.Matcher {


          /**
           * AggregationContainsPropertyEqual - checks if an aggregation contains at least one item that has a
           * Property set to a certain value.Accepts an object literal <code>mSettings</code> that defines
           * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
           * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
           * object.
           * @param mSettings optional map/JSON-object with initial settings for the new
           * AggregationContainsPropertyEqualMatcher
          */
          constructor(mSettings: any);




          /**
           * Gets current value of property <code>aggregationName</code>.The Name of the aggregation that is used
           * for matching.
           * @returns Value of property <code>aggregationName</code>
          */
          getAggregationName(): string;

          /**
           * Returns a metadata object for class sap.ui.test.matchers.AggregationContainsPropertyEqual.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Gets current value of property <code>propertyName</code>.The Name of the property that is used for
           * matching.
           * @returns Value of property <code>propertyName</code>
          */
          getPropertyName(): string;

          /**
           * Gets current value of property <code>propertyValue</code>.The value of the Property that is used for
           * matching.
           * @returns Value of property <code>propertyValue</code>
          */
          getPropertyValue(): any;

          /**
           * Checks if the control has a filled aggregation with at least one control that have a property
           * equaling propertyName/Value.
           * @param oControl the control that is checked by the matcher
           * @returns true if the Aggregation set in the property aggregationName is filled, false if it is not.
          */
          isMatching(oControl: sap.ui.core.Control): boolean;

          /**
           * Sets a new value for property <code>aggregationName</code>.The Name of the aggregation that is used
           * for matching.When called with a value of <code>null</code> or <code>undefined</code>, the default
           * value of the property will be restored.
           * @param sAggregationName New value for property <code>aggregationName</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setAggregationName(sAggregationName: string): sap.ui.test.matchers.AggregationContainsPropertyEqual;

          /**
           * Sets a new value for property <code>propertyName</code>.The Name of the property that is used for
           * matching.When called with a value of <code>null</code> or <code>undefined</code>, the default value
           * of the property will be restored.
           * @param sPropertyName New value for property <code>propertyName</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setPropertyName(sPropertyName: string): sap.ui.test.matchers.AggregationContainsPropertyEqual;

          /**
           * Sets a new value for property <code>propertyValue</code>.The value of the Property that is used for
           * matching.When called with a value of <code>null</code> or <code>undefined</code>, the default value
           * of the property will be restored.
           * @param oPropertyValue New value for property <code>propertyValue</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setPropertyValue(oPropertyValue: any): sap.ui.test.matchers.AggregationContainsPropertyEqual;
        }
      }
      /**
       * One Page Acceptance testing.
       * @resource sap/ui/test/Opa.js
      */
      export class Opa {

        /**
         * the global configuration of Opa.All of the global values can be overwritten in an individual waitFor
         * call.The default values are:<ul>		<li>arrangements: A new Opa instance</li>		<li>actions: A new Opa
         * instance</li>		<li>assertions: A new Opa instance</li>		<li>timeout : 15 seconds, is increased to 5
         * minutes if running in debug mode e.g. with URL parameter sap-ui-debug=true</li>	
         * <li>pollingInterval: 400 milliseconds</li></ul>You can either directly manipulate the config, or
         * extend it using {@link sap.ui.test.Opa#.extendConfig}
        */
        public config: any;


        /**
         * This class will help you write acceptance tests in one page or single page applications.You can wait
         * for certain conditions to be met.
         * @param extensionObject An object containing properties and functions. The newly created Opa will be
         * extended by these properties and functions using jQuery.extend.
        */
        constructor(extensionObject: any);


        /**
         * Waits until all waitFor calls are done.
         * @returns If the waiting was successful, the promise will be resolved. If not it will be rejected
        */
        emptyQueue(): any;

        /**
         * Calls the static extendConfig function in the Opa namespace {@link sap.ui.test.Opa#.extendConfig}
        */
        extendConfig(): void;

        /**
         * Extends and overwrites default values of the {@link sap.ui.test.Opa#.config}.Sample usage:<pre>   
         * <code>        var oOpa = new Opa();        // this statement will  will time out after 15 seconds
         * and poll every 400ms.        // those two values come from the defaults of {@link
         * sap.ui.test.Opa#.config}.        oOpa.waitFor({        });        // All wait for statements added
         * after this will take other defaults        Opa.extendConfig({            timeout: 10,           
         * pollingInterval: 100        });        // this statement will time out after 10 seconds and poll
         * every 100 ms        oOpa.waitFor({        });        // this statement will time out after 20
         * seconds and poll every 100 ms        oOpa.waitFor({            timeout: 20;        });   
         * </code></pre>
         * @since 1.40
         * @param options The values to be added to the existing config
        */
        extendConfig(options: any): void;

        /**
         * Gives access to a singleton object you can save values in.Same as {@link sap.ui.test.Opa#getContext}
         * @since 1.29.0
         * @returns the context object
        */
        getContext(): any;

        /**
         * Reset Opa.config to its default values.All of the global values can be overwritten in an individual
         * waitFor call.The default values are:<ul>		<li>arrangements: A new Opa instance</li>		<li>actions: A
         * new Opa instance</li>		<li>assertions: A new Opa instance</li>		<li>timeout : 15 seconds, is
         * increased to 5 minutes if running in debug mode e.g. with URL parameter sap-ui-debug=true</li>	
         * <li>pollingInterval: 400 milliseconds</li></ul>
         * @since 1.25
        */
        resetConfig(): void;

        /**
         * Clears the queue and stops running tests so that new tests can be run.This means all waitFor
         * statements registered by {@link sap.ui.test.Opa#waitFor} will not be invoked anymore andthe promise
         * returned by {@link sap.ui.test.Opa#.emptyQueue}will be rejected or resolved depending on the
         * failTest parameter.When its called inside of a check in {@link sap.ui.test.Opa#waitFor}the success
         * function of this waitFor will not be called.
         * @since 1.40.1
         * @param boolean failTest If true is passed or the parameter is omited,the promise of {@link
         * sap.ui.test.Opa#.emptyQueue} is rejected. If false is passed the promis is resolved.
        */
        stopQueue(boolean: any): void;

        /**
         * Queues up a waitFor command for Opa.The Queue will not be emptied until {@link
         * sap.ui.test.Opa#.emptyQueue} is called.If you are using {@link sap.ui.test.opaQunit}, emptyQueue
         * will be called by the wrapped tests.If you are using Opa5, waitFor takes additional parameters.They
         * can be found here: {@link sap.ui.test.Opa5#waitFor}.Waits for a check condition to return true, in
         * which case a success function will be called.If the timeout is reached before the check returns
         * true, an error function will be called.
         * @param options These contain check, success and error functions
         * @returns A promise that gets resolved on success
        */
        waitFor(options: any): any;
      }
      /**
       * UI5 extension of the OPA framework
       * @resource sap/ui/test/Opa5.js
      */
      export class Opa5 extends sap.ui.base.Object {


        /**
         * Helps you when writing tests for UI5 applications.Provides convenience to wait and retrieve for UI5
         * controls without relying on global IDs.Makes it easy to wait until your UI is in the state you need
         * for testing, e.g.: waiting for backend data.
        */
        constructor();



        /**
         * Create a page object configured as arrangement, action and assertion to the Opa.config.Use it to
         * structure your arrangement, action and assertion based on parts of the screen to avoid name clashes
         * and help to structure your tests.
         * @since 1.25
         * @param mPageObjects undefined
         * @returns mPageObject The created page object. It will look like this:<pre><code> { 
         * &lt;your-page-object-name&gt; : {      actions: // an instance of baseClass or Opa5 with all the
         * actions defined above      assertions: // an instance of baseClass or Opa5 with all the assertions
         * defined above  } }</code></pre>
        */
        createPageObjects(mPageObjects: any): any;

        /**
         * Waits until all waitFor calls are doneSee {@link sap.ui.test.Opa#.emptyQueue} for the description
         * @returns If the waiting was successful, the promise will be resolved. If not it will be rejected
        */
        emptyQueue(): any;

        /**
         * Extends and overwrites default values of the {@link sap.ui.test.Opa#.config}.Most frequent
         * usecase:<pre>    <code>        // Every waitFor will append this namespace in front of your viewName
         *        Opa5.extendConfig({           viewNamespace: "namespace.of.my.views."        });        var
         * oOpa = new Opa5();        // Looks for a control with the id "myButton" in a View with the name
         * "namespace.of.my.views.Detail"        oOpa.waitFor({             id: "myButton",            
         * viewName: "Detail"        });        // Looks for a control with the id "myList" in a View with the
         * name "namespace.of.my.views.Master"        oOpa.waitFor({             id: "myList",            
         * viewName: "Master"        });    </code></pre>Sample usage:<pre>    <code>        var oOpa = new
         * Opa5();        // this statement will  will time out after 15 seconds and poll every 400ms.       
         * // those two values come from the defaults of {@link sap.ui.test.Opa#.config}.        oOpa.waitFor({
         *        });        // All wait for statements added after this will take other defaults       
         * Opa5.extendConfig({            timeout: 10,            pollingInterval: 100        });        //
         * this statement will time out after 10 seconds and poll every 100 ms        oOpa.waitFor({        });
         *        // this statement will time out after 20 seconds and poll every 100 ms        oOpa.waitFor({ 
         *           timeout: 20;        });    </code></pre>
         * @since 1.40
         * @param options The values to be added to the existing config
        */
        extendConfig(options: any): void;

        /**
         * Gives access to a singleton object you can save values in.See {@link sap.ui.test.Opa#.getContext}
         * for the description
         * @since 1.29.0
         * @returns the context object
        */
        getContext(): any;

        /**
         * Returns HashChanger object of the IFrame. If the IFrame is not loaded it will return null.
         * @returns The HashChanger instance
        */
        getHashChanger(): sap.ui.core.routing.HashChanger;

        /**
         * Returns the jQuery object of the IFrame. If the IFrame is not loaded it will return null.
         * @returns The jQuery object
        */
        getJQuery(): typeof jQuery;

        /**
         * Returns the Opa plugin used for retrieving controls. If an IFrame is used it will return the
         * iFrame's plugin.
         * @returns The plugin instance
        */
        getPlugin(): sap.ui.test.OpaPlugin;

        /**
         * Returns QUnit utils object of the IFrame. If the IFrame is not loaded it will return null.
         * @returns The QUnit utils
        */
        getUtils(): any;

        /**
         * Returns the window object of the IFrame or the current window. If the IFrame is not loaded it will
         * return null.
         * @returns The window of the IFrame
        */
        getWindow(): any;

        /**
         * Starts an app in an IFrame. Only works reliably if running on the same server.
         * @param sSource The source of the IFrame
         * @param iTimeout The timeout for loading the IFrame in seconds - default is 80
         * @returns A promise that gets resolved on success
        */
        iStartMyAppInAFrame(sSource: string, iTimeout?: number): any;

        /**
         * Starts an app in an IFrame. Only works reliably if running on the same server.
         * @param sSource The source of the IFrame
         * @param iTimeout The timeout for loading the IFrame in seconds - default is 80
         * @returns A promise that gets resolved on success
        */
        iStartMyAppInAFrame(sSource: string, iTimeout?: number): any;

        /**
         * Starts a UIComponent.
         * @param oOptions An Object that contains the configuration for starting up a UIComponent.
         * @returns A promise that gets resolved on success.
        */
        iStartMyUIComponent(oOptions: any): any;

        /**
         * Removes the IFrame from the DOM and removes all the references to its objects
         * @returns A promise that gets resolved on success
        */
        iTeardownMyAppFrame(): any;

        /**
         * Destroys the UIComponent and removes the div from the dom like all the references on its objects
         * @returns a promise that gets resolved on success.
        */
        iTeardownMyUIComponent(): any;

        /**
         * Resets Opa.config to its default values.See {@link sap.ui.test.Opa5#waitFor} for the
         * descriptionDefault values for OPA5 are:<ul>	<li>viewNamespace: empty string</li>	<li>arrangements:
         * instance of OPA5</li>	<li>actions: instance of OPA5</li>	<li>assertions: instance of OPA5</li>
         * <li>visible: true</li>	<li>timeout : 15 seconds, is increased to 5 minutes if running in debug mode
         * e.g. with URL parameter sap-ui-debug=true</li>	<li>pollingInterval: 400 milliseconds</li></ul>
         * @since 1.25
        */
        resetConfig(): void;

        /**
         * Clears the queue and stops running tests so that new tests can be run.This means all waitFor
         * statements registered by {@link sap.ui.test.Opa5#waitFor} will not be invoked anymore andthe promise
         * returned by {@link sap.ui.test.Opa5#.emptyQueue} will be rejected.When its called inside of a check
         * in {@link sap.ui.test.Opa5#waitFor}the success function of this waitFor will not be called.
        */
        stopQueue(): void;

        /**
         * Takes the same parameters as {@link sap.ui.test.Opa#waitFor}. Also allows you to specify additional
         * parameters:
         * @param oOptions An Object containing conditions for waiting and callbacks
         * @returns A promise that gets resolved on success
        */
        waitFor(oOptions: any): any;
      }
      /**
       * A Plugin to search UI5 controls.
       * @resource sap/ui/test/OpaPlugin.js
      */
      export class OpaPlugin {


        constructor();




        /**
         * Gets all the controls of a certain type that are currently instantiated.If the control type is
         * omitted, nothing is returned.
         * @param fnConstructorType the control type, e.g: sap.m.CheckBox
         * @returns an array of the found controls (can be empty)
        */
        getAllControls(fnConstructorType: any): any[];

        /**
         * Returns a control by its idaccepts an object with an ID property the ID can bewill check a control
         * type also, if defined<ul>	<li>a single string - function will return the control instance or
         * undefined</li>	<li>an array of strings - function will return an array of found controls or an empty
         * array</li>	<li>a regexp - function will return an array of found controls or an empty
         * array</li></ul>
         * @param oOptions should contain an ID property. It can be of the type string or regex. If contains
         * controlType property, will check it as well
         * @returns all controls matched by the regex or the control matched by the string or null
        */
        getControlByGlobalId(oOptions: any): sap.ui.core.Element[];

        /**
         * Gets the constructor function of a certain controlType
         * @param sControlType the name of the type eg: "sap.m.Button"
         * @returns When the type is loaded, the contstructor is returned, if it is a lazy stub or not yet
         * loaded, null will be returned and there will be a log entry.
        */
        getControlConstructor(sControlType: string): any | any;

        /**
         * Gets a control inside of the view (same as calling oView.byId)If no ID is provided, it will return
         * all the controls inside of a view (also nested views and their children).<br/>eg : { id : "foo" }
         * will search globally for a control with the ID foo<br/>eg : { id : "foo" , viewName : "bar" } will
         * search for a control with the ID foo inside the view with the name bar<br/>eg : { viewName : "bar" }
         * will return all the controls inside the view with the name bar<br/>eg : { viewName : "bar",
         * controlType : sap.m.Button } will return all the Buttons inside a view with the name bar<br/>eg : {
         * viewName : "bar", viewNamespace : "baz." } will return all the Controls in the view with the name
         * baz.bar<br/>
         * @param oOptions that may contain a viewName, id, viewNamespace and controlType properties.
         * @returns If the passed id is a string it returns the found control or null.Else an array of matching
         * controls, if the view is not found or no control is found for multiple ids an empty array is
         * returned.
        */
        getControlInView(oOptions: any): sap.ui.core.Element | sap.ui.core.Element[] | any;

        /**
         * Tries to find a control depending on the options provided.
         * @param oOptions a map of options used to describe the control you are looking for.
         * @returns <ul>    <li>an array of found Controls depending on the options</li>    <li>an empty array
         * if no id was given</li>    <li>the found control/element when an id as a string is specified</li>   
         * <li>null if an id as string was specified</li></ul>
        */
        getMatchingControls(oOptions: any): sap.ui.core.Element | sap.ui.core.Element[] | any;

        /**
         * Returns a metadata object for class sap.ui.test.OpaPlugin.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Returns the view with a specific name - if there are multiple views with that name only the first
         * one is returned.
         * @param sViewName the name of the view
         * @returns or undefined
        */
        getView(sViewName: string): sap.ui.core.mvc.View;
      }
      /**
       * Page Object Factory
       * @resource sap/ui/test/PageObjectFactory.js
      */
      export class PageObjectFactory extends sap.ui.base.Object {





        /**
         * Create a page object configured as arrangement, action and assertion to the Opa.config.Use it to
         * structure your arrangement, action and assertion based on parts of the screen to avoid name clashes
         * and help structuring your tests.
        */
        create(): void;
      }
    }
    namespace base {
      /**
       * An Event object consisting of an id, a source and a map of parameters
       * @resource sap/ui/base/Event.js
      */
      export class Event extends sap.ui.base.Object {


        /**
         * Creates an event with the given <code>sId</code>, linked to the provided <code>oSource</code> and
         * enriched with the <code>mParameters</code>.
         * @param sId The id of the event
         * @param oSource The source of the event
         * @param mParameters A map of parameters for this event
        */
        constructor(sId: string, oSource: sap.ui.base.EventProvider, mParameters: any);



        /**
         * Cancel bubbling of the event.<b>Note:</b> This function only has an effect if the bubbling of the
         * event is supported by the event source.
        */
        cancelBubble(): void;


        /**
         * Returns the id of the event.
         * @returns The id of the event
        */
        getId(): string;

        /**
         * Returns a metadata object for class sap.ui.base.Event.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Returns the value of the parameter with the given sName.
         * @param sName The name of the parameter to return
         * @returns The value for the named parameter
        */
        getParameter(sName: string): any;

        /**
         * Returns all parameter values of the event keyed by their names.
         * @returns All parameters of the event keyed by name
        */
        getParameters(): any;

        /**
         * Returns the event provider on which the event was fired.
         * @returns The source of the event
        */
        getSource(): sap.ui.base.EventProvider;

        /**
         * Prevent the default action of this event.<b>Note:</b> This function only has an effect if preventing
         * the default action of the event is supported by the event source.
        */
        preventDefault(): void;
      }
      /**
       * Base class for all SAPUI5 Objects
       * @resource sap/ui/base/Object.js
      */
      export abstract class Object {


        /**
         * Constructor for a sap.ui.base.Object.
        */
        constructor();



        /**
         * Creates metadata for a given class and attaches it to the constructor and prototype of that
         * class.After creation, metadata can be retrieved with getMetadata().The static info can at least
         * contain the following entries:<ul><li>baseType: {string} fully qualified name of a base class or
         * empty<li>publicMethods: {string} an array of method names that will be visible in the interface
         * proxy returned by {@link #getInterface}</ul>
         * @param sClassName name of an (already declared) constructor function
         * @param oStaticInfo static info used to create the metadata object
         * @param FNMetaImpl constructor function for the metadata object. If not given, it defaults to
         * sap.ui.base.Metadata.
         * @returns the created metadata object
        */
        defineClass(sClassName: string, oStaticInfo: any, FNMetaImpl?: any): sap.ui.base.Metadata;

        /**
         * Destructor method for objects
        */
        destroy(bSuppressInvalidate: boolean): void;


        /**
         * Returns the public interface of the object.
         * @returns the public interface of the object
        */
        getInterface(): sap.ui.base.Interface;

        /**
         * Returns the metadata for the class that this object belongs to.This method is only defined when
         * metadata has been declared by using {@link sap.ui.base.Object.defineClass}or {@link
         * sap.ui.base.Object.extend}.
        */
        getMetadata(): void;
      }
      /**
       * Metadata for a class.
       * @resource sap/ui/base/Metadata.js
      */
      export class Metadata {


        /**
         * Creates a new metadata object from the given static infos.Note: throughout this class documentation,
         * the described subclass of Objectis referenced as <i>the described class</i>.
         * @param sClassName fully qualified name of the described class
         * @param oClassInfo info to construct the class and its metadata from
        */
        constructor(sClassName: string, oClassInfo: any);



        /**
         * Returns an array with the names of all public methods declared by the described classand its
         * ancestors.
         * @returns array with names of all public methods provided by the described class and its ancestors
        */
        getAllPublicMethods(): string[];

        /**
         * Returns the (constructor of the) described class
         * @returns class described by this metadata
        */
        getClass(): any;

        /**
         * Returns the fully qualified name of the described class
         * @returns name of the described class
        */
        getName(): string;

        /**
         * Returns the metadata object of the base class of the described classor null if the class has no
         * (documented) base class.
         * @returns metadata of the base class
        */
        getParent(): sap.ui.base.Metadata;

        /**
         * Returns an array with the names of the public methods declared by the described class.
         * @returns array with names of public methods declared by the described class
        */
        getPublicMethods(): string[];

        /**
         * Returns whether the described class is abstract
         * @returns whether the class is abstract
        */
        isAbstract(): boolean;

        /**
         * Whether the described class is deprecated and should not be used any more
         * @since 1.26.4
         * @returns whether the class is considered deprecated
        */
        isDeprecated(): boolean;

        /**
         * Returns whether the described class is final
         * @returns whether the class is final
        */
        isFinal(): boolean;

        /**
         * Checks whether the described class or one of its ancestor classes implements the given interface.
         * @param sInterface name of the interface to test for (in dot notation)
         * @returns whether this class implements the interface
        */
        isInstanceOf(sInterface: string): boolean;
      }
      /**
       * A class that creates an Interface for an existing class. If a class returns the interface in its
       * constructor,       only the defined functions will be visible, no internals of the class can be
       * accessed.
       * @resource sap/ui/base/Interface.js
      */
      export class Interface {


        /**
         * Constructs an instance of sap.ui.base.Interface which restricts access to methods marked as public.
         * @param oObject the instance that needs an interface created
         * @param aMethods the names of the methods, that should be available on this interface
        */
        constructor(oObject: sap.ui.base.Object, aMethods: string[]);


      }
      /**
       * Manages a pool of objects all of the same type;the type has to be specified at pool construction
       * time.Maintains a list of free objects of the given type.If {@link
       * sap.ui.base.ObjectPool.prototype.borrowObject} is called, an existing free objectis taken from the
       * pool and the <code>init</code> method is called on thisobject.When no longer needed, any borrowed
       * object should be returned tothe pool by calling {@link #returnObject}. At that point in time,the
       * reset method is called on the object and the object is added to thelist of free objects.See {@link
       * sap.ui.base.Poolable} for a description of the contract for poolable objects.Example:<pre> 
       * this.oEventPool = new sap.ui.base.ObjectPool(sap.ui.base.Event);  var oEvent =
       * this.oEventPool.borrowObject(iEventId, mParameters);</pre>
       * @resource sap/ui/base/ObjectPool.js
      */
      export class ObjectPool extends sap.ui.base.Object {


        /**
         * Creates an ObjectPool instance based on the given oObjectClass.&lt;br/&gt;If there is a free pooled
         * instance, returns that one, otherwise creates a new one.&lt;br/&gt;In order to be maintained by the
         * ObjectPool, oObjectClass must implementmethods described in the class description.
         * @param oObjectClass constructor for the class of objects that this pool should manage
        */
        constructor(oObjectClass: any);



        /**
         * Borrows a free object from the pool. Any arguments to this methodare forwarded to the init method of
         * the borrowed object.
         * @param any optional initialization parameters for the borrowed object
         * @returns the borrowed object of the same type that has been specified for this pool
        */
        borrowObject(any: any): any;


        /**
         * Returns a metadata object for class sap.ui.base.ObjectPool.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Returns an object to the pool. The object must have been borrowed from thispool beforehand. The
         * reset method is called on the object before it is addedto the set of free objects.
         * @param oObject the object to return to the pool
        */
        returnObject(oObject: any): void;
      }
      /**
       * Provides eventing capabilities for objects like attaching or detaching event handlers for events
       * which are notified when events are fired.
       * @resource sap/ui/base/EventProvider.js
      */
      export abstract class EventProvider extends sap.ui.base.Object {


        /**
         * Creates an instance of EventProvider.
        */
        constructor();



        /**
         * Attaches an event handler to the event with the given identifier.
         * @param sEventId The identifier of the event to listen for
         * @param oData An object that will be passed to the handler along with the event object when the event
         * is fired
         * @param fnFunction The handler function to call when the event occurs. This function will be called
         * in the context of the                      <code>oListener</code> instance (if present) or on the
         * event provider instance. The event                      object ({@link sap.ui.base.Event}) is
         * provided as first argument of the handler. Handlers must not change                      the content
         * of the event. The second argument is the specified <code>oData</code> instance (if present).
         * @param oListener The object that wants to be notified when the event occurs (<code>this</code>
         * context within the                       handler function). If it is not specified, the handler
         * function is called in the context of the event provider.
         * @returns Returns <code>this</code> to allow method chaining
        */
        attachEvent(sEventId: string, oData: any, fnFunction: any, oListener?: any): sap.ui.base.EventProvider;

        /**
         * Attaches an event handler, called one time only, to the event with the given identifier.When the
         * event occurs, the handler function is called and the handler registration is automatically removed
         * afterwards.
         * @param sEventId The identifier of the event to listen for
         * @param oData An object that will be passed to the handler along with the event object when the event
         * is fired
         * @param fnFunction The handler function to call when the event occurs. This function will be called
         * in the context of the                      <code>oListener</code> instance (if present) or on the
         * event provider instance. The event                      object ({@link sap.ui.base.Event}) is
         * provided as first argument of the handler. Handlers must not change                      the content
         * of the event. The second argument is the specified <code>oData</code> instance (if present).
         * @param oListener The object that wants to be notified when the event occurs (<code>this</code>
         * context within the                       handler function). If it is not specified, the handler
         * function is called in the context of the event provider.
         * @returns Returns <code>this</code> to allow method chaining
        */
        attachEventOnce(sEventId: string, oData: any, fnFunction: any, oListener?: any): sap.ui.base.EventProvider;

        /**
         * Cleans up the internal structures and removes all event handlers.The object must not be used anymore
         * after destroy was called.
        */
        destroy(bSuppressInvalidate: boolean): void;

        /**
         * Removes a previously attached event handler from the event with the given identifier.The passed
         * parameters must match those used for registration with {@link #attachEvent} beforehand.
         * @param sEventId The identifier of the event to detach from
         * @param fnFunction The handler function to detach from the event
         * @param oListener The object that wanted to be notified when the event occurred
         * @returns Returns <code>this</code> to allow method chaining
        */
        detachEvent(sEventId: string, fnFunction: any, oListener?: any): sap.ui.base.EventProvider;


        /**
         * Fires an {@link sap.ui.base.Event event} with the given settings and notifies all attached event
         * handlers.
         * @param sEventId The identifier of the event to fire
         * @param mParameters The parameters which should be carried by the event
         * @param bAllowPreventDefault Defines whether function <code>preventDefault</code> is supported on the
         * fired event
         * @param bEnableEventBubbling Defines whether event bubbling is enabled on the fired event. Set to
         * <code>true</code> the event is also forwarded to the parent(s)                                  of
         * the event provider ({@link #getEventingParent}) until the bubbling of the event is stopped or no
         * parent is available anymore.
         * @returns Returns <code>this</code> to allow method chaining. When <code>preventDefault</code> is
         * supported on the fired event                                            the function returns
         * <code>true</code> if the default action should be executed, <code>false</code> otherwise.
        */
        fireEvent(sEventId: string, mParameters?: any, bAllowPreventDefault?: boolean, bEnableEventBubbling?: boolean): sap.ui.base.EventProvider | boolean;

        /**
         * Returns the parent in the eventing hierarchy of this object.Per default this returns null, but if
         * eventing is used in objects, which are hierarchicallystructured, this can be overwritten to make the
         * object hierarchy visible to the eventing andenables the use of event bubbling within this object
         * hierarchy.
         * @returns The parent event provider
        */
        getEventingParent(): sap.ui.base.EventProvider;

        /**
         * Returns a metadata object for class sap.ui.base.EventProvider.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Returns whether there are any registered event handlers for the event with the given identifier.
         * @param sEventId The identifier of the event
         * @returns Whether there are any registered event handlers
        */
        hasListeners(sEventId: string): boolean;

        /**
         * Returns a string representation of this object.In case there is no class or id information, a simple
         * static string is returned.Subclasses should override this method.
         * @returns A string description of this event provider
        */
        toString(): string;
      }
      /**
       * Base Class that introduces some basic concepts like state management or databinding.New subclasses
       * of ManagedObject are created with a call to {@link .extend ManagedObject.extend} and can make useof
       * the following managed features:<b>Properties</b><br>Managed properties represent the state of a
       * ManagedObject. They can store a single value of a simple data type(like 'string' or 'int'). They
       * have a <i>name</i> (e.g. 'size') and methods to get the current value (<code>getSize</code>)or to
       * set a new value (<code>setSize</code>). When a property is modified, the ManagedObject is marked as
       * invalidated.A managed property can be bound against a property in a {@link sap.ui.model.Model} by
       * using the {@link #bindProperty} method.Updates to the model property will be automatically reflected
       * in the managed property and - if TwoWay databinding is active,changes to the managed property will
       * be reflected in the model. An existing binding can be removed by calling {@link #unbindProperty}.If
       * a ManagedObject is cloned, the clone will have the same values for its managed properties as the
       * source of theclone - if the property wasn't bound. If it is bound, the property in the clone will be
       * bound to the samemodel property as in the source.Details about the declaration of a managed
       * property, the metadata that describes it and the set of methods that are automaticallygenerated to
       * access it, can be found in the documentation of the {@link sap.ui.base.ManagedObject.extend extend }
       * method.<b>Aggregations</b><br>Managed aggregations can store one or more references to other
       * ManagedObjects. They are a mean to control the lifecycleof the aggregated objects: one ManagedObject
       * can be aggregated by at most one parent ManagedObject at any time.When a ManagedObject is destroyed,
       * all aggregated objects are destroyed as well and the object itself is removed fromits parent. That
       * is, aggregations won't contain destroyed objects or null/undefined.Aggregations have a <i>name</i>
       * ('e.g 'header' or 'items'), a <i>cardinality</i> ('0..1' or '0..n') and are of a specific<i>type</i>
       * (which must be a subclass of ManagedObject as well or a UI5 interface). A ManagedObject will provide
       * methods toset or get the aggregated object for a specific aggregation of cardinality 0..1 (e.g.
       * <code>setHeader</code>, <code>getHeader</code>for an aggregation named 'header'). For an aggregation
       * of cardinality 0..n, there are methods to get all aggregated objects(<code>getItems</code>), to
       * locate an object in the aggregation (e.g. <code>indexOfItem</code>), to add, insert or removea
       * single aggregated object (<code>addItem</code>, <code>insertItem</code>, <code>removeItem</code>) or
       * to remove or destroyall objects from an aggregation (<code>removeAllItems</code>,
       * <code>destroyItems</code>).Details about the declaration of a managed aggregation, the metadata that
       * describes it and the set of methods that are automaticallygenerated to access it, can be found in
       * the documentation of the {@link sap.ui.base.ManagedObject.extend extend} method.Aggregations of
       * cardinality 0..n can be bound to a collection in a model by using {@link bindAggregation} (and
       * unbound againusing {@link #unbindAggregation}. For each context in the model collection, a
       * corresponding object will be created in themanaged aggregation, either by cloning a template object
       * or by calling a factory function.Aggregations also control the databinding context of bound objects:
       * by default, aggregated objects inherit all modelsand binding contexts from their parent object.When
       * a ManagedObject is cloned, all aggregated objects will be cloned as well - but only if they haven't
       * been added bydatabinding. In that case, the aggregation in the clone will be bound to the same model
       * collection.<b>Associations</b><br>Managed associations also form a relationship between objects, but
       * they don't define a lifecycle for theassociated objects. They even can 'break' in the sense that an
       * associated object might have been destroyed alreadyalthough it is still referenced in an
       * association. For the same reason, the internal storage for associationsare not direct object
       * references but only the IDs of the associated target objects.Associations have a <i>name</i> ('e.g
       * 'initialFocus'), a <i>cardinality</i> ('0..1' or '0..n') and are of a specific <i>type</i>(which
       * must be a subclass of ManagedObject as well or a UI5 interface). A ManagedObject will provide
       * methods to set or getthe associated object for a specific association of cardinality 0..1 (e.g.
       * <code>setInitialFocus</code>, <code>getInitialFocus</code>).For an association of cardinality 0..n,
       * there are methods to get all associated objects (<code>getRefItems</code>),to add, insert or remove
       * a single associated object (<code>addRefItem</code>,<code>insertRefItem</code>,
       * <code>removeRefItem</code>) or to remove all objects from an
       * association(<code>removeAllRefItems</code>).Details about the declaration of a managed association,
       * the metadata that describes it and the set of methods that are automaticallygenerated to access it,
       * can be found in the documentation of the {@link sap.ui.base.ManagedObject.extend extend}
       * method.Associations can't be bound to the model.When a ManagedObject is cloned, the result for an
       * association depends on the relationship between the associated targetobject and the root of the
       * clone operation: if the associated object is part of the to-be-cloned object tree (reachablevia
       * aggregations from the root of the clone operation), then the cloned association will reference the
       * clone of theassociated object. Otherwise it will reference the same object as in the original
       * tree.When a ManagedObject is destroyed, other objects that are only associated, are not affected by
       * the destroy operation.<b>Events</b><br>Managed events provide a mean for communicating important
       * state changes to an arbitrary number of 'interested' listeners.Events have a <i>name</i> and
       * (optionally) a set of <i>parameters</i>. For each event there will be methods to add or remove an
       * eventlistener as well as a method to fire the event. (e.g. <code>attachChange</code>,
       * <code>detachChange</code>, <code>fireChange</code>for an event named 'change').Details about the
       * declaration of a managed events, the metadata that describes it and the set of methods that are
       * automaticallygenerated to access it, can be found in the documentation of the {@link
       * sap.ui.base.ManagedObject.extend extend} method.When a ManagedObject is cloned, all listeners
       * registered for any event in the clone source are also registered to theclone. Later changes are not
       * reflect in any direction (neither from source to clone nor vice versa).<a name="lowlevelapi"><b>Low
       * Level APIs:</b></a><br>The prototype of ManagedObject provides several generic, low level APIs to
       * manage properties, aggregations, associationsand events. These generic methods are solely intended
       * for implementing higher level, non-generic methods that managea single managed property etc. (e.g. a
       * function <code>setSize(value)</code> that sets a new value for property 'size').{@link
       * sap.ui.base.ManagedObject.extend} creates default implementations of those higher level APIs for all
       * managed aspects.The implementation of a subclass then can override those default implementations
       * with a more specific implementation,e.g. to implement a side effect when a specific property is set
       * or retrieved.It is therefore important to understand that the generic low-level methods ARE NOT
       * SUITABLE FOR GENERIC ACCESS to thestate of a managed object, as that would bypass the overriding
       * higher level methods and their side effects.
       * @resource sap/ui/base/ManagedObject.js
      */
      export class ManagedObject extends sap.ui.base.EventProvider {


        /**
         * Constructs and initializes a managed object with the given <code>sId</code> and settings.If the
         * optional <code>mSettings</code> are given, they must be a simple objectthat defines values for
         * properties, aggregations, associations or events keyed by their name.<b>Valid Names and Value
         * Ranges:</b>The property (key) names supported in the object literal are exactly the (case
         * sensitive)names documented in the JSDoc for the properties, aggregations, associations and eventsof
         * the current class and its base classes. Note that for 0..n aggregations and associations thisname
         * usually is the plural name, whereas it is the singular name in case of 0..1 relations.If a key name
         * is ambiguous for a specific managed object class (e.g. a property has the samename as an event),
         * then this method prefers property, aggregation, association andevent in that order. To resolve such
         * ambiguities, the keys can be prefixed with<code>aggregation:</code>, <code>association:</code> or
         * <code>event:</code>(such keys containing a colon (':') must be quoted to be valid Javascript).The
         * possible values for a setting depend on its kind:<ul><li>for simple properties, the value has to
         * match the documented type of the property (no type conversion occurs)<li>for 0..1 aggregations, the
         * value has to be an instance of the aggregated type<li>for 0..n aggregations, the value has to be an
         * array of instances of the aggregated type or a single instance<li>for 0..1 associations, an instance
         * of the associated type or an id (string) is accepted<li>for 0..n associations, an array of instances
         * of the associated type or of Ids is accepted<li>for events either a function (event handler) is
         * accepted or an array of length 2    where the first element is a function and the 2nd element is an
         * object to invoke the method on.</ul>Each subclass should document the name and type of its supported
         * settings in its constructor documentation.Besides the settings documented below, ManagedObject
         * itself supports the following special settings:<ul><li><code>id : <i>any</i></code> an ID
         * for the new instance. Some subclasses (Element, Component) require the id  to be unique in a
         * specific scope (e.g. an Element Id must be unique across all Elements, a Component id must  be
         * unique across all Components).<li><code>models : <i>object</i></code> a map of {@link
         * sap.ui.model.Model} instances keyed by their model name (alias).  Each entry with key <i>k</i> in
         * this object has the same effect as a call <code>this.setModel(models[k],
         * k);</code>.</li><li><code>bindingContexts : <i>object</i></code> a map of {@link
         * sap.ui.model.Context} instances keyed by their model name.  Each entry with key <i>k</i> in this
         * object has the same effect as a call <code>this.setBindingContext(bindingContexts[k],
         * k);</code></li><li><code>objectBindings : <i>object</i></code>  a map of binding paths keyed by the
         * corresponding model name.  Each entry with key <i>k</i> in this object has the same effect as a call
         * <code>this.bindObject(objectBindings[k], k);</code></li></ul>
         * @param sId id for the new managed object; generated automatically if no non-empty id is given    
         * Note: this can be omitted, no matter whether <code>mSettings</code> will be given or not!
         * @param mSettings Optional map/JSON-object with initial property values, aggregated objects etc. for
         * the new object
         * @param oScope Scope object for resolving string based type and formatter references in bindings.    
         * When a scope object is given, <code>mSettings</code> cannot be omitted, at least <code>null</code>
         * or an empty object literal must be given.
        */
        constructor(sId: string, mSettings?: any, oScope?: any);



        /**
         * Adds some entity <code>oObject</code> to the aggregation identified by
         * <code>sAggregationName</code>.If the given object is not valid with regard to the aggregation (if it
         * is not an instanceof the type specified for that aggregation) or when the method is called for an
         * aggregationof cardinality 0..1, then an Error is thrown (see {@link #validateAggregation}.If the
         * aggregation already has content, the new object will be added after the current content.If the new
         * object was already contained in the aggregation, it will be moved to the end.<b>Note:</b> This
         * method is a low-level API as described in <a href="#lowlevelapi">the class
         * documentation</a>.Applications or frameworks must not use this method to generically add an object
         * to an aggregation.Use the concrete method add<i>XYZ</i> for aggregation 'XYZ' or the generic {@link
         * #applySettings} instead.
         * @param sAggregationName the string identifying the aggregation that <code>oObject</code> should be
         * added to.
         * @param oObject the object to add; if empty, nothing is added
         * @param bSuppressInvalidate if true, this ManagedObject as well as the added child are not marked as
         * changed
         * @returns Returns <code>this</code> to allow method chaining
        */
        addAggregation(sAggregationName: string, oObject: sap.ui.base.ManagedObject, bSuppressInvalidate?: boolean): sap.ui.base.ManagedObject;

        /**
         * Adds some object with the ID <code>sId</code> to the association identified by
         * <code>sAssociationName</code> andmarks this ManagedObject as changed.This method does not avoid
         * duplicates.<b>Note:</b> This method is a low-level API as described in <a href="#lowlevelapi">the
         * class documentation</a>.Applications or frameworks must not use this method to generically add an
         * object to an association.Use the concrete method add<i>XYZ</i> for association 'XYZ' or the generic
         * {@link #applySettings} instead.
         * @param sAssociationName the string identifying the association the object should be added to.
         * @param sId the ID of the ManagedObject object to add; if empty, nothing is added; if a
         * <code>sap.ui.base.ManagedObject</code> is given, its ID is added
         * @param bSuppressInvalidate if true, this managed object as well as the newly associated object are
         * not marked as changed
         * @returns Returns <code>this</code> to allow method chaining
        */
        addAssociation(sAssociationName: string, sId: string | sap.ui.base.ManagedObject, bSuppressInvalidate?: boolean): sap.ui.base.ManagedObject;

        /**
         * Sets all the properties, aggregations, associations and event handlers as given inthe object literal
         * <code>mSettings</code>. If a property, aggregation, etc.is not listed in <code>mSettings</code>,
         * then its value is not changed by this method.For properties and 0..1 aggregations/associations, any
         * given setting overwritesthe current value. For 0..n aggregations, the given values are appended;
         * eventlisteners are registered in addition to existing ones.For the possible keys and values in
         * <code>mSettings</code> see the generaldocumentation in {@link sap.ui.base.ManagedObject} or the
         * specific documentationof the constructor of the concrete managed object class.
         * @param mSettings the settings to apply to this managed object
         * @param oScope Scope object to resolve types and formatters
         * @returns Returns <code>this</code> to allow method chaining
        */
        applySettings(mSettings: any, oScope?: any): sap.ui.base.ManagedObject;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>formatError</code> event of this
         * <code>sap.ui.base.ManagedObject</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.base.ManagedObject</code> itself.Fired when a new value for a bound property
         * should have been propagated from the model,but formatting the value failed with an exception.
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.base.ManagedObject</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachFormatError(oData: any, fnFunction: any, oListener?: any): sap.ui.base.ManagedObject;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>modelContextChange</code> event of this
         * <code>sap.ui.base.ManagedObject</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.base.ManagedObject</code> itself.Fired when models or contexts are changed on
         * this object (either by calling setModel/setBindingContext or due to propagation)
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.base.ManagedObject</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachModelContextChange(oData: any, fnFunction: any, oListener?: any): sap.ui.base.ManagedObject;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>parseError</code> event of this
         * <code>sap.ui.base.ManagedObject</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.base.ManagedObject</code> itself.Fired when a new value for a bound property
         * should have been propagated to the model,but parsing the value failed with an exception.
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.base.ManagedObject</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachParseError(oData: any, fnFunction: any, oListener?: any): sap.ui.base.ManagedObject;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>validationError</code> event of this
         * <code>sap.ui.base.ManagedObject</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.base.ManagedObject</code> itself.Fired when a new value for a bound property
         * should have been propagated to the model,but validating the value failed with an exception.
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.base.ManagedObject</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachValidationError(oData: any, fnFunction: any, oListener?: any): sap.ui.base.ManagedObject;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>validationSuccess</code> event of this
         * <code>sap.ui.base.ManagedObject</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.base.ManagedObject</code> itself.Fired after a new value for a bound property
         * has been propagated to the model.Only fired, when the binding uses a data type.
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.base.ManagedObject</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachValidationSuccess(oData: any, fnFunction: any, oListener?: any): sap.ui.base.ManagedObject;

        /**
         * Bind an aggregation to the model.The bound aggregation will use the given template, clone it for
         * each itemwhich exists in the bound list and set the appropriate binding context.This is a generic
         * method which can be used to bind any aggregation to themodel. A managed object may flag aggregations
         * in the metamodel withbindable="bindable" to get typed bind<i>Something</i> methods for those
         * aggregations.
         * @param sName the aggregation to bind
         * @param oBindingInfo the binding info
         * @returns reference to the instance itself
        */
        bindAggregation(sName: string, oBindingInfo: any): sap.ui.base.ManagedObject;

        /**
         * Bind the object to the referenced entity in the model, which is used as the binding contextto
         * resolve bound properties or aggregations of the object itself and all of its childrenrelatively to
         * the given path.
         * @param sPath the binding path
         * @returns reference to the instance itself
        */
        bindContext(sPath: string): sap.ui.base.ManagedObject;

        /**
         * Bind the object to the referenced entity in the model, which is used as the binding contextto
         * resolve bound properties or aggregations of the object itself and all of its childrenrelatively to
         * the given path.If a relative binding path is used, this will be applied whenever the parent context
         * changes.
         * @param vPath the binding path or an object with more detailed binding options
         * @param mParameters map of additional parameters for this binding (only taken into account when vPath
         * is a string in that case the properties described for vPath above are valid here).The supported
         * parameters are listed in the corresponding model-specific implementation of
         * <code>sap.ui.model.ContextBinding</code>.
         * @returns reference to the instance itself
        */
        bindObject(vPath: string | any, mParameters?: any): sap.ui.base.ManagedObject;

        /**
         * Bind a property to the model.The Setter for the given property will be called with the value
         * retrievedfrom the data model.This is a generic method which can be used to bind any property to
         * themodel. A managed object may flag properties in the metamodel withbindable="bindable" to get typed
         * bind methods for a property.A composite property binding which may have multiple paths (also known
         * as Calculated Fields) can be declared using the parts parameter.Note a composite binding is read
         * only (One Way).
         * @param sName the name of the property
         * @param oBindingInfo the binding information
         * @returns reference to the instance itself
        */
        bindProperty(sName: string, oBindingInfo: any): sap.ui.base.ManagedObject;

        /**
         * Clones a tree of objects starting with the object on which clone is called first (root object).The
         * ids within the newly created clone tree are derived from the original ids by appendingthe given
         * <code>sIdSuffix</code> (if no suffix is given, one will be created; it will beunique across multiple
         * clone calls).The <code>oOptions</code> configuration object can have the following
         * properties:<ul><li>The boolean value <code>cloneChildren</code> specifies wether
         * associations/aggregations will be cloned</li><li>The boolean value <code>cloneBindings</code>
         * specifies if bindings will be cloned</li></ul>For each cloned object the following settings are
         * cloned based on the metadata of the object and the defined options:<ul><li>all properties that are
         * not bound. If cloneBinding is false even these properties will be cloned;the values are used by
         * reference, they are not cloned</li><li>all aggregated objects that are not bound. If cloneBinding is
         * false even the ones that are bound will be cloned;they are all cloned recursively using the same
         * <code>sIdSuffix</code></li><li>all associated controls; when an association points to an object
         * inside the cloned object tree,    then the cloned association will be modified to that it points to
         * the clone of the target object.    When the association points to a managed object outside of the
         * cloned object tree, then its    target won't be changed.</li><li>all models set via setModel(); used
         * by reference </li><li>all property and aggregation bindings (if cloneBindings is true); the pure
         * binding infos (path, model name) are    cloned, but all other information like template control or
         * factory function,    data type or formatter function are copied by reference. The bindings
         * themselves    are created anew as they are specific for the combination (object, property, model).  
         *  As a result, any later changes to a binding of the original object are not reflected    in the
         * clone, but changes to e.g the type or template etc. are.</li></ul>Each clone is created by first
         * collecting the above mentioned settings and then creatinga new instance with the normal constructor
         * function. As a result, any side effects ofmutator methods (setProperty etc.) or init hooks are
         * repeated during clone creation.There is no need to override <code>clone()</code> just to reproduce
         * these internal settings!Custom controls however can override <code>clone()</code> to implement
         * additional clone steps.They usually will first call <code>clone()</code> on the super class and then
         * modify thereturned clone accordingly.Applications <b>must never provide</b> the second parameter
         * <code>aLocaleIds</code>.It is determined automatically for the root object (and its non-existance
         * also serves asan indicator for the root object). Specifying it will break the implementation of
         * <code>clone()</code>.
         * @param sIdSuffix a suffix to be appended to the cloned object id
         * @param aLocalIds an array of local IDs within the cloned hierarchy (internally used)
         * @param oOptions configuration object
         * @returns reference to the newly created clone
        */
        clone(sIdSuffix: string, aLocalIds?: string[], oOptions?: any): sap.ui.base.ManagedObject;

        /**
         * Creates a new ManagedObject from the given data.If vData is a managed object already, that object is
         * returned.If vData is an object (literal), then a new object is created with vData as settings.The
         * type of the object is either determined by a "Type" entry in the vData orby a type information in
         * the oKeyInfo object
         * @param vData the data to create the object from
         * @param oKeyInfo undefined
         * @param oScope Scope object to resolve types and formatters in bindings
        */
        create(vData: sap.ui.base.ManagedObject | any, oKeyInfo: any, oScope?: any): void;

        /**
         * Cleans up the resources associated with this object and all its aggregated children.After an object
         * has been destroyed, it can no longer be used in!Applications should call this method if they don't
         * need the object any longer.
         * @param bSuppressInvalidate if true, this ManagedObject is not marked as changed
        */
        destroy(bSuppressInvalidate: boolean): void;

        /**
         * Destroys (all) the managed object(s) in the aggregation named <code>sAggregationName</code> and
         * empties theaggregation. If the aggregation did contain any object, this ManagedObject is marked as
         * changed.<b>Note:</b> This method is a low-level API as described in <a href="#lowlevelapi">the class
         * documentation</a>.Applications or frameworks must not use this method to generically destroy all
         * objects in an aggregation.Use the concrete method destroy<i>XYZ</i> for aggregation 'XYZ' instead.
         * @param sAggregationName the name of the aggregation
         * @param bSuppressInvalidate if true, this ManagedObject is not marked as changed
         * @returns Returns <code>this</code> to allow method chaining
        */
        destroyAggregation(sAggregationName: string, bSuppressInvalidate?: boolean): sap.ui.base.ManagedObject;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>formatError</code> event of this
         * <code>sap.ui.base.ManagedObject</code>.The passed function and listener object must match the ones
         * used for event registration.
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachFormatError(fnFunction: any, oListener: any): sap.ui.base.ManagedObject;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>modelContextChange</code> event of
         * this <code>sap.ui.base.ManagedObject</code>.The passed function and listener object must match the
         * ones used for event registration.
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachModelContextChange(fnFunction: any, oListener: any): sap.ui.base.ManagedObject;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>parseError</code> event of this
         * <code>sap.ui.base.ManagedObject</code>.The passed function and listener object must match the ones
         * used for event registration.
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachParseError(fnFunction: any, oListener: any): sap.ui.base.ManagedObject;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>validationError</code> event of this
         * <code>sap.ui.base.ManagedObject</code>.The passed function and listener object must match the ones
         * used for event registration.
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachValidationError(fnFunction: any, oListener: any): sap.ui.base.ManagedObject;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>validationSuccess</code> event of this
         * <code>sap.ui.base.ManagedObject</code>.The passed function and listener object must match the ones
         * used for event registration.
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachValidationSuccess(fnFunction: any, oListener: any): sap.ui.base.ManagedObject;


        /**
         * Searches and returns an array of child elements and controls which arereferenced within an
         * aggregation or aggregations of child elements/controls.This can be either done recursive or not.
         * Optionally a condition function can be passed thatreturns true if the object should be added to the
         * array.<br><b>Take care: this operation might be expensive.</b>
         * @param bRecursive true, if all nested children should be returned.
         * @param fnCondition if given, the object is passed as a parameter to the.
         * @returns array of child elements and controls
        */
        findAggregatedObjects(bRecursive: boolean, fnCondition: boolean): sap.ui.base.ManagedObject[];

        /**
         * Fires event <code>formatError</code> to attached listeners.Expects the following event
         * parameters:<ul><li><code>element</code> of type <code>sap.ui.base.ManagedObject</code>ManagedObject
         * instance whose property should have received the model update.</li><li><code>property</code> of type
         * <code>string</code>Name of the property for which the binding should have been
         * updated.</li><li><code>type</code> of type <code>sap.ui.model.Type</code>Data type used in the
         * binding (if any).</li><li><code>newValue</code> of type <code>any</code>New value (model
         * representation) as propagated from the model.</li><li><code>oldValue</code> of type
         * <code>any</code>Old value (external representation) as previously stored in the
         * ManagedObject.</li></ul>
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireFormatError(mArguments: any): sap.ui.base.ManagedObject;

        /**
         * Fires event <code>modelContextChange</code> to attached listeners.
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireModelContextChange(mArguments: any): sap.ui.base.ManagedObject;

        /**
         * Fires event <code>parseError</code> to attached listeners.Expects the following event
         * parameters:<ul><li><code>element</code> of type <code>sap.ui.base.ManagedObject</code>ManagedObject
         * instance whose property initiated the model update.</li><li><code>property</code> of type
         * <code>string</code>Name of the property for which the bound model property should have been been
         * updated.</li><li><code>type</code> of type <code>sap.ui.model.Type</code>Data type used in the
         * binding.</li><li><code>newValue</code> of type <code>any</code>New value (external representation)
         * as parsed by the binding.</li><li><code>oldValue</code> of type <code>any</code>Old value (external
         * representation) as previously stored in the ManagedObject.</li><li><code>message</code> of type
         * <code>string</code>Localized message describing the parse error</li></ul>
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireParseError(mArguments: any): sap.ui.base.ManagedObject;

        /**
         * Fires event <code>validationError</code> to attached listeners.Expects the following event
         * parameters:<ul><li><code>element</code> of type <code>sap.ui.base.ManagedObject</code>ManagedObject
         * instance whose property initiated the model update.</li><li><code>property</code> of type
         * <code>string</code>Name of the property for which the bound model property should have been been
         * updated.</li><li><code>type</code> of type <code>sap.ui.model.Type</code>Data type used in the
         * binding.</li><li><code>newValue</code> of type <code>any</code>New value (external representation)
         * as parsed and validated by the binding.</li><li><code>oldValue</code> of type <code>any</code>Old
         * value (external representation) as previously stored in the
         * ManagedObject.</li><li><code>message</code> of type <code>string</code>Localized message describing
         * the validation issues</li></ul>
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireValidationError(mArguments: any): sap.ui.base.ManagedObject;

        /**
         * Fires event <code>validationSuccess</code> to attached listeners.Expects the following event
         * parameters:<ul><li><code>element</code> of type <code>sap.ui.base.ManagedObject</code>ManagedObject
         * instance whose property initiated the model update.</li><li><code>property</code> of type
         * <code>string</code>Name of the property for which the bound model property has been
         * updated.</li><li><code>type</code> of type <code>sap.ui.model.Type</code>Data type used in the
         * binding.</li><li><code>newValue</code> of type <code>any</code>New value (external representation)
         * as propagated to the model.<b>Note: </b>the model might modify (normalize) the value again and this
         * modificationwill be stored in the ManagedObject. The 'newValue' parameter of this event containsthe
         * value <b>before</b> such a normalization.</li><li><code>oldValue</code> of type <code>any</code>Old
         * value (external representation) as previously stored in the ManagedObject.</li></ul>
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireValidationSuccess(mArguments: any): sap.ui.base.ManagedObject;

        /**
         * Returns the aggregated object(s) for the named aggregation of this ManagedObject.If the aggregation
         * does not contain any objects(s), the given <code>oDefaultForCreation</code>(or <code>null</code>) is
         * set as new value of the aggregation and returned to the caller.<b>Note:</b> the need to specify a
         * default value and the fact that it is stored asnew value of a so far empty aggregation is recognized
         * as a shortcoming of this APIbut can no longer be changed for compatibility reasons.<b>Note:</b> This
         * method is a low-level API as described in <a href="#lowlevelapi">the class
         * documentation</a>.Applications or frameworks must not use this method to generically read the
         * content of an aggregation.Use the concrete method get<i>XYZ</i> for aggregation 'XYZ' instead.
         * @param sAggregationName the name of the aggregation
         * @param oDefaultForCreation the object that is used in case the current aggregation is empty
         * @returns the aggregation array in case of 0..n-aggregations or the managed object or null in case of
         * 0..1-aggregations
        */
        getAggregation(sAggregationName: string, oDefaultForCreation: sap.ui.base.ManagedObject | any[]): sap.ui.base.ManagedObject | any[];

        /**
         * Returns the content of the association wit hthe given name.For associations of cardinality 0..1, a
         * single string with the ID of an associatedobject is returned (if any). For cardinality 0..n, an
         * array with the IDs of theassociated objects is returned.If the association does not contain any
         * objects(s), the given <code>oDefaultForCreation</code>is set as new value of the association and
         * returned to the caller. The only supported values for<code>oDefaultForCreation</code> are
         * <code>null</code> and <code>undefined</code> in the case ofcardinality 0..1 and <code>null</code>,
         * <code>undefined</code> or an empty array (<code>[]</code>)in case of cardinality 0..n. If the
         * argument is omitted, <code>null</code> is used independentlyfrom the cardinality.<b>Note:</b> the
         * need to specify a default value and the fact that it is stored asnew value of a so far empty
         * association is recognized as a shortcoming of this APIbut can no longer be changed for compatibility
         * reasons.<b>Note:</b> This method is a low-level API as described in <a href="#lowlevelapi">the class
         * documentation</a>.Applications or frameworks must not use this method to generically retrieve the
         * content of an association.Use the concrete method get<i>XYZ</i> for association 'XYZ' instead.
         * @param sAssociationName the name of the association
         * @param oDefaultForCreation the object that is used in case the current aggregation is empty (only
         * null or empty array allowed)
         * @returns the ID of the associated managed object or an array of such IDs; may be null if the
         * association has not been populated
        */
        getAssociation(sAssociationName: string, oDefaultForCreation: any): string | string[];

        /**
         * Get the binding object for a specific aggregation/property
         * @param sName the name of the property or aggregation
         * @returns the binding for the given name
        */
        getBinding(sName: string): sap.ui.model.Binding;

        /**
         * Get the binding context of this object for the given model name.If the object does not have a
         * binding context set on itself and has no own Model set,it will use the first binding context defined
         * in its parent hierarchy.Note: to be compatible with future versions of this API, applications must
         * not use the value <code>null</code>,the empty string <code>""</code> or the string literals
         * <code>"null"</code> or <code>"undefined"</code> as model name.Note: A ManagedObject inherits binding
         * contexts from the Core only when it is a descendant of an UIArea.
         * @param sModelName the name of the model or <code>undefined</code>
         * @returns oContext The binding context of this object
        */
        getBindingContext(sModelName: string): sap.ui.model.Context;

        /**
         * Returns the binding infos for the given property or aggregation. The binding info contains
         * information about path, binding object, format options,sorter, filter etc. for the property or
         * aggregation.
         * @param sName the name of the property or aggregation
         * @returns the binding info object, containing at least a path property                  and,
         * dependant of the binding type, additional properties
        */
        getBindingInfo(sName: string): any;

        /**
         * Get the binding path for a specific aggregation/property
         * @param sName the name of the property or aggregation
         * @returns the binding path for the given name
        */
        getBindingPath(sName: string): string;

        /**
         * Returns the parent managed object as new eventing parent to enable control event bubblingor
         * <code>null</code> if this object hasn't been added to a parent yet.
         * @returns the parent event provider
        */
        getEventingParent(): sap.ui.base.EventProvider;

        /**
         * Returns the object's Id.
         * @returns the objects's Id.
        */
        getId(): string;

        /**
         * Returns the metadata for the class that this object belongs to.
         * @returns Metadata for the class of the object
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Get the model to be used for data bindings with the given model name.If the object does not have a
         * model set on itself, it will use the firstmodel defined in its parent hierarchy.The name can be
         * omitted to reference the default model or it must be a non-empty string.Note: to be compatible with
         * future versions of this API, applications must not use the value <code>null</code>,the empty string
         * <code>""</code> or the string literals <code>"null"</code> or <code>"undefined"</code> as model
         * name.
         * @param sName name of the model to be retrieved
         * @returns oModel
        */
        getModel(sName: string | any): sap.ui.model.Model;

        /**
         * Get the object binding object for a specific model
         * @param sModelName the name of the model
         * @returns the element binding for the given model name
        */
        getObjectBinding(sModelName: string): sap.ui.model.Binding;

        /**
         * Returns the origin info for the value of the given property.The origin info might contain additional
         * information for translatabletexts. The bookkeeping of this information is not active by default and
         * must beactivated by configuration. Even then, it might not be present for all propertiesand their
         * values depending on where the value came form.
         * @param sPropertyName the name of the property
         * @returns a map of properties describing the origin of this property value or null
        */
        getOriginInfo(sPropertyName: string): any;

        /**
         * Returns the parent managed object or <code>null</code> if this object hasn't been added to a parent
         * yet.
         * @returns The parent managed object or <code>null</code>
        */
        getParent(): sap.ui.base.ManagedObject;

        /**
         * Returns the value for the property with the given <code>sPropertyName</code>.<b>Note:</b> This
         * method is a low-level API as described in <a href="#lowlevelapi">the class
         * documentation</a>.Applications or frameworks must not use this method to generically retrieve the
         * value of a property.Use the concrete method get<i>XYZ</i> for property 'XYZ' instead.
         * @param sPropertyName the name of the property
        */
        getProperty(sPropertyName: string): any;

        /**
         * Check if any model is set to the ManagedObject or to one of its parents (including UIArea and
         * Core).Note: A ManagedObject inherits models from the Core only when it is a descendant of an UIArea.
         * @returns whether a model reference exists or not
        */
        hasModel(): boolean;

        /**
         * Searches for the provided ManagedObject in the named aggregation and returns its0-based index if
         * found, or -1 otherwise. Returns -2 if the given named aggregationis of cardinality 0..1 and doesn't
         * reference the given object.<b>Note:</b> This method is a low-level API as described in <a
         * href="#lowlevelapi">the class documentation</a>.Applications or frameworks must not use this method
         * to generically determine the position of an object in an aggregation.Use the concrete method
         * indexOf<i>XYZ</i> for aggregation 'XYZ' instead.
         * @param sAggregationName the name of the aggregation
         * @param oObject the ManagedObject whose index is looked for.
         * @returns the index of the provided managed object in the aggregation.
        */
        indexOfAggregation(sAggregationName: string, oObject: sap.ui.base.ManagedObject): number;

        /**
         * Inserts managed object <code>oObject</code> to the aggregation named <code>sAggregationName</code>
         * atposition <code>iIndex</code>.If the given object is not valid with regard to the aggregation (if
         * it is not an instanceof the type specified for that aggregation) or when the method is called for an
         * aggregationof cardinality 0..1, then an Error is thrown (see {@link #validateAggregation}.If the
         * given index is out of range with respect to the current content of the aggregation,it is clipped to
         * that range (0 for iIndex < 0, n for iIndex > n).Please note that this method does not work as
         * expected when an object is addedthat is already part of the aggregation. In order to change the
         * index of an objectinside an aggregation, first remove it, then insert it again.<b>Note:</b> This
         * method is a low-level API as described in <a href="#lowlevelapi">the class
         * documentation</a>.Applications or frameworks must not use this method to generically insert an
         * object into an aggregation.Use the concrete method insert<i>XYZ</i> for aggregation 'XYZ' instead.
         * @param sAggregationName the string identifying the aggregation the managed object
         * <code>oObject</code>           should be inserted into.
         * @param oObject the ManagedObject to add; if empty, nothing is inserted.
         * @param iIndex the <code>0</code>-based index the managed object should be inserted at; for a
         * negative           value <code>iIndex</code>, <code>oObject</code> is inserted at position 0; for a
         * value           greater than the current size of the aggregation, <code>oObject</code> is inserted
         * at           the last position
         * @param bSuppressInvalidate if true, this ManagedObject as well as the added child are not marked as
         * changed
         * @returns Returns <code>this</code> to allow method chaining
        */
        insertAggregation(sAggregationName: string, oObject: sap.ui.base.ManagedObject, iIndex: number, bSuppressInvalidate?: boolean): sap.ui.base.ManagedObject;

        /**
         * This triggers rerendering of itself and its children.<br/> As <code>sap.ui.base.ManagedObject</code>
         * "bubbles up" theinvalidate, changes to child-<code>Elements</code> will also result in rerendering
         * of the whole sub tree.
        */
        invalidate(oOrigin?: any): void;

        /**
         * Find out whether a property or aggregation is bound
         * @param sName the name of the property or aggregation
         * @returns whether a binding exists for the given name
        */
        isBound(sName: string): boolean;

        /**
         * Returns whether rerendering is currently suppressed on this ManagedObject
        */
        isInvalidateSuppressed(): void;

        /**
         * This method is used internally and should only be overridden by a tree managed object which utilizes
         * the tree binding. In this case and if the aggregation is a tree node the overridden method should
         * then return true. If true is returned the tree binding will be used instead of the list binding.
         * @param sName the aggregation to bind (e.g. nodes for a tree managed object)
         * @returns whether tree binding should be used or list binding. Default is false. Override method to
         * change this behavior.
        */
        isTreeBinding(sName: string): boolean;

        /**
         * Generic method which is called, whenever messages for this object exists.
         * @since 1.28
         * @param sName The property name
         * @param aMessages The messages
        */
        propagateMessages(sName: string, aMessages: any[]): void;

        /**
         * Removes an object from the aggregation named <code>sAggregationName</code> with cardinality 0..n.The
         * removed object is not destroyed nor is it marked as changed.If the given object is found in the
         * aggreation, it is removed, it's parent relationshipis unset and this ManagedObject is marked as
         * changed. The removed object is returned asresult of this method. If the object could not be found,
         * <code>undefined</code> is returned.This method must only be called for aggregations of cardinality
         * 0..n. The only way to remove objectsfrom a 0..1 aggregation is to set a <code>null</code> value for
         * them.<b>Note:</b> This method is a low-level API as described in <a href="#lowlevelapi">the class
         * documentation</a>.Applications or frameworks must not use this method to generically remove an
         * object from an aggregation.Use the concrete method remove<i>XYZ</i> for aggregation 'XYZ' instead.
         * @param sAggregationName the string identifying the aggregation that the given object should be
         * removed from
         * @param vObject the position or ID of the ManagedObject that should be removed or that ManagedObject
         * itself;           if <code>vObject</code> is invalid, a negative value or a value greater or equal
         * than the current size           of the aggregation, nothing is removed.
         * @param bSuppressInvalidate if true, this ManagedObject is not marked as changed
         * @returns the removed object or null
        */
        removeAggregation(sAggregationName: string, vObject: number | string | sap.ui.base.ManagedObject, bSuppressInvalidate?: boolean): sap.ui.base.ManagedObject;

        /**
         * Removes all objects from the 0..n-aggregation named <code>sAggregationName</code>.The removed
         * objects are not destroyed nor are they marked as changed.Additionally, it clears the parent
         * relationship of all removed objects, marks thisManagedObject as changed and returns an array with
         * the removed objects.If the aggregation did not contain any objects, an empty array is returned and
         * thisManagedObject is not marked as changed.<b>Note:</b> This method is a low-level API as described
         * in <a href="#lowlevelapi">the class documentation</a>.Applications or frameworks must not use this
         * method to generically remove all objects from an aggregation.Use the concrete method
         * removeAll<i>XYZ</i> for aggregation 'XYZ' instead.
         * @param sAggregationName the name of the aggregation
         * @param bSuppressInvalidate if true, this ManagedObject is not marked as changed
         * @returns an array of the removed elements (might be empty)
        */
        removeAllAggregation(sAggregationName: string, bSuppressInvalidate?: boolean): any[];

        /**
         * Removes all the objects in the 0..n-association named <code>sAssociationName</code> and returns an
         * arraywith their IDs. This ManagedObject is marked as changed, if the association contained any
         * objects.<b>Note:</b> This method is a low-level API as described in <a href="#lowlevelapi">the class
         * documentation</a>.Applications or frameworks must not use this method to generically remove all
         * object from an association.Use the concrete method removeAll<i>XYZ</i> for association 'XYZ'
         * instead.
         * @param sAssociationName the name of the association
         * @param bSuppressInvalidate if true, this ManagedObject is not marked as changed
         * @returns an array with the IDs of the removed objects (might be empty)
        */
        removeAllAssociation(sAssociationName: string, bSuppressInvalidate?: boolean): any[];

        /**
         * Removes a ManagedObject from the association named <code>sAssociationName</code>.If an object is
         * removed, the Id of that object is returned and this ManagedObject ismarked as changed. Otherwise
         * <code>undefined</code> is returned.If the same object was added multiple times to the same
         * association, only a singleoccurence of it will be removed by this method. If the object is not found
         * or if theparameter can't be interpreted neither as a ManagedObject (or id) nor as an index inthe
         * assocation, nothing will be removed. The same is true if an index is given and ifthat index is out
         * of range for the association.<b>Note:</b> This method is a low-level API as described in <a
         * href="#lowlevelapi">the class documentation</a>.Applications or frameworks must not use this method
         * to generically remove an object from an association.Use the concrete method remove<i>XYZ</i> for
         * association 'XYZ' instead.
         * @param sAssociationName the string identifying the association the ManagedObject should be removed
         * from.
         * @param vObject the position or ID of the ManagedObject to remove or the ManagedObject itself; if
         * <code>vObject</code> is invalid input,           a negative value or a value greater or equal than
         * the current size of the association, nothing is removed
         * @param bSuppressInvalidate if true, the managed object is not marked as changed
        */
        removeAssociation(sAssociationName: string, vObject: number | string | sap.ui.base.ManagedObject, bSuppressInvalidate?: boolean): void;

        /**
         * Sets a new object in the named 0..1 aggregation of this ManagedObject andmarks this ManagedObject as
         * changed.If the given object is not valid with regard to the aggregation (if it is not an instanceof
         * the type specified for that aggregation) or when the method is called for an aggregationof
         * cardinality 0..n, then an Error is thrown (see {@link #validateAggregation}.If the new object is the
         * same as the currently aggregated object, then the internal stateis not modified and this
         * ManagedObject is not marked as changed.If the given object is different, the parent of a previously
         * aggregated object is cleared(it must have been this ManagedObject before), the parent of the given
         * object is set to thisManagedObject and {@link #invalidate} is called for this object.Note that this
         * method does neither return nor destroy the previously aggregated object.This behavior is inherited
         * by named set methods (see below) in subclasses.To avoid memory leaks, applications therefore should
         * first get the aggregated object,keep a reference to it or destroy it, depending on their needs, and
         * only then set a newobject.Note that ManagedObject only implements a single level of change tracking:
         * if a firstcall to setAggregation recognizes a change, 'invalidate' is called. If another call
         * tosetAggregation reverts that change, invalidate() will be called again, the new statusis not
         * recognized as being 'clean' again.<b>Note:</b> This method is a low-level API as described in <a
         * href="#lowlevelapi">the class documentation</a>.Applications or frameworks must not use this method
         * to generically set an object in an aggregation.Use the concrete method set<i>XYZ</i> for aggregation
         * 'XYZ' or the generic {@link #applySettings} instead.
         * @param sAggregationName name of an 0..1 aggregation
         * @param oObject the managed object that is set as aggregated object
         * @param bSuppressInvalidate if true, this ManagedObject is not marked as changed
         * @returns Returns <code>this</code> to allow method chaining
        */
        setAggregation(sAggregationName: string, oObject: any, bSuppressInvalidate?: boolean): sap.ui.base.ManagedObject;

        /**
         * Sets the associatied object for the given managed association of cardinality '0..1' andmarks this
         * ManagedObject as changed.The associated object can either be given by itself or by its id. If
         * <code>null</code> or<code>undefined</code> is given, the association is cleared.<b>Note:</b> This
         * method is a low-level API as described in <a href="#lowlevelapi">the class
         * documentation</a>.Applications or frameworks must not use this method to generically set an object
         * in an association.Use the concrete method set<i>XYZ</i> for association 'XYZ' or the generic {@link
         * #applySettings} instead.
         * @param sAssociationName name of the association
         * @param sId the ID of the managed object that is set as an association, or the managed object itself
         * or null
         * @param bSuppressInvalidate if true, the managed objects invalidate method is not called
         * @returns Returns <code>this</code> to allow method chaining
        */
        setAssociation(sAssociationName: string, sId: string | sap.ui.base.ManagedObject, bSuppressInvalidate?: boolean): sap.ui.base.ManagedObject;

        /**
         * Set the binding context for this ManagedObject for the model with the given name.Note: to be
         * compatible with future versions of this API, applications must not use the value
         * <code>null</code>,the empty string <code>""</code> or the string literals <code>"null"</code> or
         * <code>"undefined"</code> as model name.Note: A ManagedObject inherits binding contexts from the Core
         * only when it is a descendant of an UIArea.
         * @param oContext the new binding context for this object
         * @param sModelName the name of the model to set the context for or <code>undefined</code>
         * @returns reference to the instance itself
        */
        setBindingContext(oContext: any, sModelName?: string): sap.ui.base.ManagedObject;

        /**
         * Sets or unsets a model for the given model name for this ManagedObject.The <code>sName</code> must
         * either be <code>undefined</code> (or omitted) or a non-empty string.When the name is omitted, the
         * default model is set/unset.When <code>oModel</code> is <code>null</code> or <code>undefined</code>,
         * a previously set modelwith that name is removed from this ManagedObject. If an ancestor (parent,
         * UIArea or Core) has a modelwith that name, this ManagedObject will immediately inherit that model
         * from its ancestor.All local bindings that depend on the given model name, are updated (created if
         * the model referencesbecame complete now; updated, if any model reference has changed; removed if the
         * model referencesbecame incomplete now).Any change (new model, removed model, inherited model) is
         * also applied to all aggregated descendantsas long as a descendant doesn't have its own model set for
         * the given name.Note: to be compatible with future versions of this API, applications must not use
         * the value <code>null</code>,the empty string <code>""</code> or the string literals
         * <code>"null"</code> or <code>"undefined"</code> as model name.Note: By design, it is not possible to
         * hide an inherited model by setting a <code>null</code> or<code>undefined</code> model. Applications
         * can set an empty model to achieve the same.Note: A ManagedObject inherits models from the Core only
         * when it is a descendant of an UIArea.
         * @param oModel the model to be set or <code>null</code> or <code>undefined</code>
         * @param sName the name of the model or <code>undefined</code>
         * @returns <code>this</code> to allow method chaining
        */
        setModel(oModel: sap.ui.model.Model, sName?: string): sap.ui.base.ManagedObject;

        /**
         * Sets the given value for the given property after validating and normalizing it,marks this object as
         * changed.If the value is not valid with regard to the declared data type of the property,an Error is
         * thrown. In case <code>null</code> or <code>undefined</code> is passed,the default value for this
         * property is used (see {@link #validateProperty}. If the validated and normalized<code>oValue</code>
         * equals the current value of the property, the internal state ofthis object is not changed. If the
         * value changes, it is stored internally andthe {@link #invalidate} method is called on this object.
         * In the case of TwoWaydatabinding, the bound model is informed about the property change.Note that
         * ManagedObject only implements a single level of change tracking: if a firstcall to setProperty
         * recognizes a change, 'invalidate' is called. If another call tosetProperty reverts that change,
         * invalidate() will be called again, the new statusis not recognized as being 'clean'
         * again.<b>Note:</b> This method is a low level API as described in <a href="#lowlevelapi">the class
         * documentation</a>.Applications or frameworks must not use this method to generically set a
         * property.Use the concrete method set<i>XYZ</i> for property 'XYZ' or the generic {@link
         * #applySettings} instead.
         * @param sPropertyName name of the property to set
         * @param oValue value to set the property to
         * @param bSuppressInvalidate if true, the managed object is not marked as changed
         * @returns Returns <code>this</code> to allow method chaining
        */
        setProperty(sPropertyName: string, oValue: any, bSuppressInvalidate?: boolean): sap.ui.base.ManagedObject;

        /**
         * Returns a simple string representation of this managed object.Mainly useful for tracing purposes.
         * @returns a string description of this managed object
        */
        toString(): string;

        /**
         * Unbind the aggregation from the model
         * @param sName the name of the aggregation
         * @param bSuppressReset whether the reset to empty aggregation when unbinding should be suppressed
         * @returns reference to the instance itself
        */
        unbindAggregation(sName: string, bSuppressReset: boolean): sap.ui.base.ManagedObject;

        /**
         * Removes the defined binding context of this object, all bindings will now resolverelative to the
         * parent context again.
         * @param sModelName name of the model to remove the context for.
         * @returns reference to the instance itself
        */
        unbindContext(sModelName: string): sap.ui.base.ManagedObject;

        /**
         * Removes the defined binding context of this object, all bindings will now resolverelative to the
         * parent context again.
         * @param sModelName name of the model to remove the context for.
         * @returns reference to the instance itself
        */
        unbindObject(sModelName: string): sap.ui.base.ManagedObject;

        /**
         * Unbind the property from the model
         * @param sName the name of the property
         * @param bSuppressReset whether the reset to the default value when unbinding should be suppressed
         * @returns reference to the instance itself
        */
        unbindProperty(sName: string, bSuppressReset: boolean): sap.ui.base.ManagedObject;

        /**
         * Checks whether the given value is of the proper type for the given aggregation name.This method is
         * already called by {@link #setAggregation}, {@link #addAggregation} and {@link #insertAggregation}.In
         * many cases, subclasses of ManagedObject don't need to call it again in their mutator methods.
         * @param sAggregationName the name of the aggregation
         * @param oObject the aggregated object or a primitive value
         * @param bMultiple whether the caller assumes the aggregation to have cardinality 0..n
         * @returns the passed object
        */
        validateAggregation(sAggregationName: string, oObject: sap.ui.base.ManagedObject | any, bMultiple: boolean): sap.ui.base.ManagedObject | any;

        /**
         * Checks whether the given value is of the proper type for the given property name.In case
         * <code>null</code> or <code>undefined</code> is passed, the default value forthis property is used as
         * value. If no default value is defined for the property, thedefault value of the type of the property
         * is used.If the property has a data type that is an instance of sap.ui.base.DataType and ifa
         * <code>normalize</code> function is defined for that type, that function will becalled with the
         * resulting value as only argument. The result of the function call isthen used instead of the raw
         * value.This method is called by {@link #setProperty}. In many cases, subclasses ofManagedObject don't
         * need to call it themselves.
         * @param sPropertyName the name of the property
         * @param oValue the value
         * @returns the normalized value for the passed value or for the default value if null or undefined was
         * passed
        */
        validateProperty(sPropertyName: string, oValue: any): any;
      }
      /**
       * Contract for objects that can be pooled by ObjectPool
       * @resource sap/ui/base/ObjectPool.js
      */
      interface Poolable {



        /**
         * Called by the object pool when this instance will be actived for a caller.The same method will be
         * called after a new instance has been created by an otherwiseexhausted pool.If the caller provided
         * any arguments to {@link sap.ui.base.ObjectPool#borrowObject}all arguments will be propagated to this
         * method.
        */
        init(): void;

        /**
         * Called by the object pool when an instance is returned to the pool.While no specific implementation
         * is required, poolable objects in generalshould clean all caller specific state (set to null) in this
         * method toavoid memory leaks and to enforce garbage collection of the caller state.
        */
        reset(): void;
      }
    }
    namespace core {

      /**
       * Applies the support for custom style classes on the prototype of a
       * <code>sap.ui.core.Element</code>.All controls (subclasses of <code>sap.ui.core.Control</code>)
       * provide the support custom style classes. The control API provides functionsto the application which
       * allow it to add, remove or change style classes for the control.In general, this option is not
       * available for elements because elements do not necessarily have a representation in the DOM.This
       * function can be used by a control developer to explicitly enrich the API of their element
       * implementation with the API functionsfor the custom style class support. It must be called on the
       * prototype of the element.<b>Usage Example:</b><pre>sap.ui.define(['sap/ui/core/Element',
       * 'sap/ui/core/CustomStyleClassSupport'], function(Element, CustomStyleClassSupport) {   "use strict";
       *   var MyElement = Element.extend("my.MyElement", {      metadata : {         //...      }      //...
       *   });   CustomStyleClassSupport.apply(MyElement.prototype);   return MyElement;},
       * true);</pre>Furthermore, the function <code>oRenderManager.writeClasses(oElement);</code> ({@link
       * sap.ui.core.RenderManager#writeClasses}) must be called withinthe renderer of the control to which
       * the element belongs, when writing the root tag of the element. This ensures the classes are written
       * to the HTML.This function adds the following functions to the elements
       * prototype:<ul><li><code>addStyleClass</code>: {@link
       * sap.ui.core.Control#addStyleClass}</li><li><code>removeStyleClass</code>: {@link
       * sap.ui.core.Control#removeStyleClass}</li><li><code>toggleStyleClass</code>: {@link
       * sap.ui.core.Control#toggleStyleClass}</li><li><code>hasStyleClass</code>: {@link
       * sap.ui.core.Control#hasStyleClass}</li></ul>In addition the clone function of the element is
       * extended to ensure that the custom style classes are also available on the cloned
       * element.<b>Note:</b> This function can only be used <i>within</i> control development. An
       * application cannot add style class support on existing elements by calling this function.
      */
      function CustomStyleClassSupport(): void;
      namespace ID {
      }
      namespace ws {
        namespace ReadyState {

          /**
           * The connection has been closed or could not be opened.
          */
          var CLOSED: any;

          /**
           * The connection is going through the closing handshake.
          */
          var CLOSING: any;

          /**
           * The connection has not yet been established.
          */
          var CONNECTING: any;

          /**
           * The WebSocket connection is established and communication is possible.
          */
          var OPEN: any;
        }
        namespace SapPcpWebSocket.SUPPORTED_PROTOCOLS {

          /**
           * Protocol v10.pcp.sap.com
          */
          var v10: any;
        }
        /**
         * Basic WebSocket class
         * @resource sap/ui/core/ws/WebSocket.js
        */
        export class WebSocket extends sap.ui.base.EventProvider {


          /**
           * Creates a new WebSocket connection.
           * @param sUrl relative or absolute URL for WebSocket connection.
           * @param aProtocols array of protocols as strings, a single protocol as a string
          */
          constructor(sUrl: string, aProtocols?: any[]);



          /**
           * Attach event-handler <code>fnFunction</code> to the 'close' event of this
           * <code>sap.ui.core.ws.WebSocket</code>.<br>
           * @param oData The object, that should be passed along with the event-object when firing the event.
           * @param fnFunction The function to call, when the event occurs. This function will be called on the  
           *         oListener-instance (if present) or in a 'static way'.
           * @param oListener Object on which to call the given function. If empty, this WebSocket is used.
           * @returns <code>this</code> to allow method chaining
          */
          attachClose(oData: any, fnFunction: any, oListener?: any): sap.ui.core.ws.WebSocket;

          /**
           * Attach event-handler <code>fnFunction</code> to the 'error' event of this
           * <code>sap.ui.core.ws.WebSocket</code>.<br>
           * @param oData The object, that should be passed along with the event-object when firing the event.
           * @param fnFunction The function to call, when the event occurs. This function will be called on the  
           *         oListener-instance (if present) or in a 'static way'.
           * @param oListener Object on which to call the given function. If empty, this WebSocket is used.
           * @returns <code>this</code> to allow method chaining
          */
          attachError(oData: any, fnFunction: any, oListener?: any): sap.ui.core.ws.WebSocket;

          /**
           * Attach event-handler <code>fnFunction</code> to the 'message' event of this
           * <code>sap.ui.core.ws.WebSocket</code>.<br>
           * @param oData The object, that should be passed along with the event-object when firing the event.
           * @param fnFunction The function to call, when the event occurs. This function will be called on the  
           *         oListener-instance (if present) or in a 'static way'.
           * @param oListener Object on which to call the given function. If empty, this WebSocket is used.
           * @returns <code>this</code> to allow method chaining
          */
          attachMessage(oData: any, fnFunction: any, oListener?: any): sap.ui.core.ws.WebSocket;

          /**
           * Attach event-handler <code>fnFunction</code> to the 'open' event of this
           * <code>sap.ui.core.ws.WebSocket</code>.<br>
           * @param oData The object, that should be passed along with the event-object when firing the event.
           * @param fnFunction The function to call, when the event occurs. This function will be called on the  
           *         oListener-instance (if present) or in a 'static way'.
           * @param oListener Object on which to call the given function. If empty, this WebSocket is used.
           * @returns <code>this</code> to allow method chaining
          */
          attachOpen(oData: any, fnFunction: any, oListener?: any): sap.ui.core.ws.WebSocket;

          /**
           * Closes the connection.
           * @param iCode Status code that explains why the connection is closed. Must be either 1000, or between
           * 3000 and 4999 (default 1000)
           * @param sReason Closing reason as a string
           * @returns <code>this</code> to allow method chaining
          */
          close(iCode: number, sReason?: string): sap.ui.core.ws.WebSocket;

          /**
           * Detach event-handler <code>fnFunction</code> from the 'close' event of this
           * <code>sap.ui.core.ws.WebSocket</code>.<br>The passed function and listener object must match the
           * ones previously used for event registration.
           * @param fnFunction The function to call, when the event occurs.
           * @param oListener Object on which the given function had to be called.
           * @returns <code>this</code> to allow method chaining
          */
          detachClose(fnFunction: any, oListener: any): sap.ui.core.ws.WebSocket;

          /**
           * Detach event-handler <code>fnFunction</code> from the 'error' event of this
           * <code>sap.ui.core.ws.WebSocket</code>.<br>The passed function and listener object must match the
           * ones previously used for event registration.
           * @param fnFunction The function to call, when the event occurs.
           * @param oListener Object on which the given function had to be called.
           * @returns <code>this</code> to allow method chaining
          */
          detachError(fnFunction: any, oListener: any): sap.ui.core.ws.WebSocket;

          /**
           * Detach event-handler <code>fnFunction</code> from the 'message' event of this
           * <code>sap.ui.core.ws.WebSocket</code>.<br>The passed function and listener object must match the
           * ones previously used for event registration.
           * @param fnFunction The function to call, when the event occurs.
           * @param oListener Object on which the given function had to be called.
           * @returns <code>this</code> to allow method chaining
          */
          detachMessage(fnFunction: any, oListener: any): sap.ui.core.ws.WebSocket;

          /**
           * Detach event-handler <code>fnFunction</code> from the 'open' event of this
           * <code>sap.ui.core.ws.WebSocket</code>.<br>The passed function and listener object must match the
           * ones previously used for event registration.
           * @param fnFunction The function to call, when the event occurs.
           * @param oListener Object on which the given function had to be called.
           * @returns <code>this</code> to allow method chaining
          */
          detachOpen(fnFunction: any, oListener: any): sap.ui.core.ws.WebSocket;


          /**
           * Fire event 'close' to attached listeners.
           * @param mArguments the arguments to pass along with the event.
           * @returns <code>this</code> to allow method chaining
          */
          fireClose(mArguments: any): sap.ui.core.ws.WebSocket;

          /**
           * Fire event 'error' to attached listeners.
           * @param mArguments the arguments to pass along with the event.
           * @returns <code>this</code> to allow method chaining
          */
          fireError(mArguments: any): sap.ui.core.ws.WebSocket;

          /**
           * Fire event 'message' to attached listeners.
           * @param mArguments the arguments to pass along with the event.
           * @returns <code>this</code> to allow method chaining
          */
          fireMessage(mArguments: any): sap.ui.core.ws.WebSocket;

          /**
           * Fire event 'open' to attached listeners.
           * @param mArguments the arguments to pass along with the event.
           * @returns <code>this</code> to allow method chaining
          */
          fireOpen(mArguments: any): sap.ui.core.ws.WebSocket;

          /**
          */
          getInterface(): sap.ui.base.Interface;

          /**
           * Returns a metadata object for class sap.ui.core.ws.WebSocket.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Getter for the protocol selected by the server once the connection is open.
           * @returns protocol
          */
          getProtocol(): string;

          /**
           * Getter for WebSocket readyState.
           * @returns readyState
          */
          getReadyState(): typeof sap.ui.core.ws.ReadyState;

          /**
           * Sends a message.<br><br>If the connection is not yet opened, the message will be queued and sentwhen
           * the connection is established.
           * @param sMessage Message to send
           * @returns <code>this</code> to allow method chaining
          */
          send(sMessage: string): sap.ui.core.ws.WebSocket;
        }
        /**
         * WebSocket class implementing the pcp-protocol
         * @resource sap/ui/core/ws/SapPcpWebSocket.js
        */
        export class SapPcpWebSocket extends sap.ui.core.ws.WebSocket {


          /**
           * Creates a new WebSocket connection and uses the pcp-protocol for communication.
           * @param sUrl relative or absolute URL for WebSocket connection.
           * @param aProtocols array of protocols as strings, a single protocol as a string.Protocol(s) should be
           * selected from {@link sap.ui.core.ws.SapPcpWebSocket.SUPPORTED_PROTOCOLS}.
          */
          constructor(sUrl: string, aProtocols?: any[]);




          /**
           * Fire event 'message' to attached listeners.
           * @param mArguments the arguments to pass along with the event.
           * @returns <code>this</code> to allow method chaining
          */
          fireMessage(mArguments: any): sap.ui.core.ws.SapPcpWebSocket;

          /**
           * Returns a metadata object for class sap.ui.core.ws.SapPcpWebSocket.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Sends a message and optional pcp-header-fields using the pcp-protocol.<br><br>If the connection is
           * not yet opened, the message will be queued and sentwhen the connection is established.
           * @param message message to send
           * @param oPcpFields additional pcp-fields as key-value map
           * @returns <code>this</code> to allow method chaining
          */
          send(message: string | any | any[], oPcpFields?: any): sap.ui.core.ws.SapPcpWebSocket;
        }
      }
      namespace mvc {
        namespace View {
          /**
           * Interface for Preprocessor implementations that can be hooked in the view life cycle.There are two
           * possibilities to use the preprocessor. It can be either passed to the view via the
           * mSettings.preprocessors objectwhere it is the executed only for this instance, or by the
           * registerPreprocessor method of the view type. Currently this isavailable only for XMLViews (as of
           * version 1.30).
           * @resource sap/ui/core/mvc/View.js
          */
          interface Preprocessor {



            /**
             * Processing method that must be implemented by a Preprocessor.
             * @param vSource the source to be processed
             * @param oViewInfo identification information about the calling instance
             * @param mSettings settings object containing the settings provided with the preprocessor
             * @returns the processed resource or a promise which resolves with the processed resource or an error
             * according to the		declared preprocessor sync capability
            */
            process(vSource: any, oViewInfo: any, mSettings?: any): any | JQueryPromise<any>;
          }
          /**
           * Specifies possible view types
          */
          namespace mvc {
            enum ViewType {
              HTML,
              JS,
              JSON,
              Template,
              XML
            }
          }
        }
        namespace XMLView {
          /**
           * Specifies the available preprocessor types for XMLViews
          */
          enum PreprocessorType {
            CONTROLS,
            VIEWXML,
            XML
          }
        }
        /**
         * A base class for Views.Introduces the relationship to a Controller, some basic visual appearance
         * settings like width and heightand provides lifecycle events.
         * @resource sap/ui/core/mvc/View.js
        */
        export class View extends sap.ui.core.Control {


          /**
           * Constructor for a new View.Accepts an object literal <code>mSettings</code> that defines
           * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
           * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
           * object.
           * @param sId id for the new control, generated automatically if no id is given
           * @param mSettings initial settings for the new control
          */
          constructor(sId: string, mSettings?: any);



          /**
           * Adds some content to the aggregation <code>content</code>.
           * @param oContent the content to add; if empty, nothing is inserted
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          addContent(oContent: sap.ui.core.Control): sap.ui.core.mvc.View;

          /**
           * Attaches event handler <code>fnFunction</code> to the <code>afterInit</code> event of this
           * <code>sap.ui.core.mvc.View</code>.When called, the context of the event handler (its
           * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
           * to this <code>sap.ui.core.mvc.View</code> itself.Fired when the View has parsed the UI description
           * and instantiated the contained controls (/control tree).
           * @param oData An application-specific payload object that will be passed to the event handler along
           * with the event object when firing the event
           * @param fnFunction The function to be called when the event occurs
           * @param oListener Context object to call the event handler with. Defaults to this
           * <code>sap.ui.core.mvc.View</code> itself
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          attachAfterInit(oData: any, fnFunction: any, oListener?: any): sap.ui.core.mvc.View;

          /**
           * Attaches event handler <code>fnFunction</code> to the <code>afterRendering</code> event of this
           * <code>sap.ui.core.mvc.View</code>.When called, the context of the event handler (its
           * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
           * to this <code>sap.ui.core.mvc.View</code> itself.Fired when the View has been (re-)rendered and its
           * HTML is present in the DOM.
           * @param oData An application-specific payload object that will be passed to the event handler along
           * with the event object when firing the event
           * @param fnFunction The function to be called when the event occurs
           * @param oListener Context object to call the event handler with. Defaults to this
           * <code>sap.ui.core.mvc.View</code> itself
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          attachAfterRendering(oData: any, fnFunction: any, oListener?: any): sap.ui.core.mvc.View;

          /**
           * Attaches event handler <code>fnFunction</code> to the <code>beforeExit</code> event of this
           * <code>sap.ui.core.mvc.View</code>.When called, the context of the event handler (its
           * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
           * to this <code>sap.ui.core.mvc.View</code> itself.Fired when the view has received the request to
           * destroy itself, but before it has destroyed anything.
           * @param oData An application-specific payload object that will be passed to the event handler along
           * with the event object when firing the event
           * @param fnFunction The function to be called when the event occurs
           * @param oListener Context object to call the event handler with. Defaults to this
           * <code>sap.ui.core.mvc.View</code> itself
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          attachBeforeExit(oData: any, fnFunction: any, oListener?: any): sap.ui.core.mvc.View;

          /**
           * Attaches event handler <code>fnFunction</code> to the <code>beforeRendering</code> event of this
           * <code>sap.ui.core.mvc.View</code>.When called, the context of the event handler (its
           * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
           * to this <code>sap.ui.core.mvc.View</code> itself.Fired before this View is re-rendered. Use to
           * unbind event handlers from HTML elements etc.
           * @param oData An application-specific payload object that will be passed to the event handler along
           * with the event object when firing the event
           * @param fnFunction The function to be called when the event occurs
           * @param oListener Context object to call the event handler with. Defaults to this
           * <code>sap.ui.core.mvc.View</code> itself
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          attachBeforeRendering(oData: any, fnFunction: any, oListener?: any): sap.ui.core.mvc.View;

          /**
           * Returns an element by its ID in the context of the view.
           * @param sId View local ID of the element
           * @returns element by its ID or <code>undefined</code>
          */
          byId(sId: string): sap.ui.core.Element;

          /**
           * Override clone method to avoid conflict between generic cloning of contentand content creation as
           * defined by the UI5 Model View Controller lifecycle.For more details see the development guide
           * section about Model View Controller in UI5.
           * @param sIdSuffix a suffix to be appended to the cloned element id
           * @param aLocalIds an array of local IDs within the cloned hierarchy (internally used)
           * @returns reference to the newly created clone
          */
          clone(sIdSuffix: string, aLocalIds?: string[]): sap.ui.base.ManagedObject;

          /**
           * Convert the given view local element ID to a globally unique IDby prefixing it with the view ID.
           * @param sId View local ID of the element
           * @returns prefixed id
          */
          createId(sId: string): string;

          /**
           * Destroys all the content in the aggregation <code>content</code>.
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          destroyContent(): sap.ui.core.mvc.View;

          /**
           * Detaches event handler <code>fnFunction</code> from the <code>afterInit</code> event of this
           * <code>sap.ui.core.mvc.View</code>.The passed function and listener object must match the ones used
           * for event registration.
           * @param fnFunction The function to be called, when the event occurs
           * @param oListener Context object on which the given function had to be called
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          detachAfterInit(fnFunction: any, oListener: any): sap.ui.core.mvc.View;

          /**
           * Detaches event handler <code>fnFunction</code> from the <code>afterRendering</code> event of this
           * <code>sap.ui.core.mvc.View</code>.The passed function and listener object must match the ones used
           * for event registration.
           * @param fnFunction The function to be called, when the event occurs
           * @param oListener Context object on which the given function had to be called
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          detachAfterRendering(fnFunction: any, oListener: any): sap.ui.core.mvc.View;

          /**
           * Detaches event handler <code>fnFunction</code> from the <code>beforeExit</code> event of this
           * <code>sap.ui.core.mvc.View</code>.The passed function and listener object must match the ones used
           * for event registration.
           * @param fnFunction The function to be called, when the event occurs
           * @param oListener Context object on which the given function had to be called
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          detachBeforeExit(fnFunction: any, oListener: any): sap.ui.core.mvc.View;

          /**
           * Detaches event handler <code>fnFunction</code> from the <code>beforeRendering</code> event of this
           * <code>sap.ui.core.mvc.View</code>.The passed function and listener object must match the ones used
           * for event registration.
           * @param fnFunction The function to be called, when the event occurs
           * @param oListener Context object on which the given function had to be called
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          detachBeforeRendering(fnFunction: any, oListener: any): sap.ui.core.mvc.View;


          /**
           * Fires event <code>afterInit</code> to attached listeners.
           * @param mArguments The arguments to pass along with the event
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          fireAfterInit(mArguments: any): sap.ui.core.mvc.View;

          /**
           * Fires event <code>afterRendering</code> to attached listeners.
           * @param mArguments The arguments to pass along with the event
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          fireAfterRendering(mArguments: any): sap.ui.core.mvc.View;

          /**
           * Fires event <code>beforeExit</code> to attached listeners.
           * @param mArguments The arguments to pass along with the event
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          fireBeforeExit(mArguments: any): sap.ui.core.mvc.View;

          /**
           * Fires event <code>beforeRendering</code> to attached listeners.
           * @param mArguments The arguments to pass along with the event
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          fireBeforeRendering(mArguments: any): sap.ui.core.mvc.View;

          /**
           * Gets content of aggregation <code>content</code>.Child Controls of the view
          */
          getContent(): sap.ui.core.Control[];

          /**
           * Returns the view's Controller instance or null for a controller-less View.
           * @returns Controller of this view.
          */
          getController(): any;

          /**
           * An (optional) method to be implemented by Views. When no controller instance is given at View
           * instantiation timeAND this method exists and returns the (package and class) name of a controller,
           * the View tries to load andinstantiate the controller and to connect it to itself.
           * @returns the name of the controller
          */
          getControllerName(): string;

          /**
           * Gets current value of property <code>displayBlock</code>.Whether the CSS display should be set to
           * "block".Set this to "true" if the default display "inline-block" causes a vertical scrollbar with
           * Views that are set to 100% height.Do not set this to "true" if you want to display other content in
           * the same HTML parent on either side of the View (setting to "true" may push that other content to
           * the next/previous line).Default value is <code>false</code>.
           * @returns Value of property <code>displayBlock</code>
          */
          getDisplayBlock(): boolean;

          /**
           * Gets current value of property <code>height</code>.The height
           * @returns Value of property <code>height</code>
          */
          getHeight(): any;

          /**
           * Returns the local ID of an element by removing the view ID prefix or<code>null</code> if the ID does
           * not contain a prefix.
           * @since 1.39.0
           * @param sId Prefixed ID
           * @returns ID without prefix or <code>null</code>
          */
          getLocalId(sId: string): string;

          /**
           * Returns a metadata object for class sap.ui.core.mvc.View.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Returns the info object which is also passed to the preprocessors
           * @param bSync Describes the view execution, true if sync
           * @returns Info object for the view
          */
          getPreprocessorInfo(bSync: boolean): any;

          /**
           * Returns user specific data object
           * @returns viewData
          */
          getViewData(): any;

          /**
           * Gets current value of property <code>viewName</code>.Name of the View
           * @returns Value of property <code>viewName</code>
          */
          getViewName(): string;

          /**
           * Gets current value of property <code>width</code>.The widthDefault value is <code>100%</code>.
           * @returns Value of property <code>width</code>
          */
          getWidth(): any;

          /**
           * Checks if any preprocessors are active for the specified type
           * @param sType Type of the preprocessor, e.g. "raw", "xml" or "controls"
           * @returns <code>true</code> if a preprocessor is active
          */
          hasPreprocessor(sType: string): boolean;

          /**
           * Checks for the provided <code>sap.ui.core.Control</code> in the aggregation <code>content</code>.and
           * returns its index if found or -1 otherwise.
           * @param oContent The content whose index is looked for
           * @returns The index of the provided control in the aggregation if found, or -1 otherwise
          */
          indexOfContent(oContent: sap.ui.core.Control): number;

          /**
           * Inserts a content into the aggregation <code>content</code>.
           * @param oContent the content to insert; if empty, nothing is inserted
           * @param iIndex the <code>0</code>-based index the content should be inserted at; for             a
           * negative value of <code>iIndex</code>, the content is inserted at position 0; for a value           
           *  greater than the current size of the aggregation, the content is inserted at             the last
           * position
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          insertContent(oContent: sap.ui.core.Control, iIndex: number): sap.ui.core.mvc.View;

          /**
           * Creates a Promise representing the state of the view initialization.For views that are loading
           * asynchronously (by setting async=true) this Promise is created by viewinitialization. Synchronously
           * loading views get wrapped in an immediately resolving Promise.
           * @since 1.30
           * @returns resolves with the complete view instance, reject with any thrown error
          */
          loaded(): JQueryPromise<any>;

          /**
           * Register a preprocessor for all views of a specific type.The preprocessor can be registered for
           * several stages of view initialization, which aredependant from the view type, e.g. "raw", "xml" or
           * already initialized "controls". If there is a preprocessorpassed to or activated at the view
           * instance already, that one is used. When several preprocessors are registeredfor one hook, it has to
           * be made sure that they do not conflict when beeing processed serially.It can be either a module name
           * as string of an implementation of {@link sap.ui.core.mvc.View.Preprocessor} or afunction with a
           * signature according to {@link sap.ui.core.mvc.View.Preprocessor.process}.<strong>Note</strong>:
           * Preprocessors only work in async views and will be ignored when the view is instantiatedin sync mode
           * by default, as this could have unexpected side effects. You may override this behaviour by setting
           * the<code>bSyncSupport</code> flag to <code>true</code>.
           * @param sType the type of content to be processed
           * @param vPreprocessor module path of the preprocessor implementation or a preprocessor function
           * @param sViewType type of the calling view, e.g. <code>XML</code>
           * @param bSyncSupport declares if the vPreprocessor ensures safe sync processing. This means the
           * preprocessor will be executed		also for sync views. Please be aware that any kind of async
           * processing (like Promises, XHR, etc) may		break the view initialization and lead to unexpected
           * results.
           * @param bOnDemand on-demand preprocessor which enables developers to quickly activate the
           * preprocessor for a view,		by setting <code>preprocessors : { xml }</code>, for example. This should
           * be false except for very special		cases. There can only be one on-demand preprocessor per content
           * type.
           * @param mSettings optional configuration for preprocessor
          */
          registerPreprocessor(sType: string | sap.ui.core.mvc.XMLView.PreprocessorType, vPreprocessor: string | any, bSyncSupport: boolean, bOnDemand?: boolean, mSettings?: any): void;

          /**
           * Removes all the controls from the aggregation <code>content</code>.Additionally, it unregisters them
           * from the hosting UIArea.
           * @returns An array of the removed elements (might be empty)
          */
          removeAllContent(): sap.ui.core.Control[];

          /**
           * Removes a content from the aggregation <code>content</code>.
           * @param vContent The content to remove or its index or id
           * @returns The removed content or <code>null</code>
          */
          removeContent(vContent: number | string | sap.ui.core.Control): sap.ui.core.Control;

          /**
           * Executes preprocessors for a type of source
           * @param sType the type of preprocessor, e.g. "raw", "xml" or "controls"
           * @param vSource the view source as a JSON object, a raw text, an XML document element or a Promise
           * resolving with those
           * @param bSync describes the view execution, true if sync
           * @returns a promise resolving with the processed source or an error | the source when bSync=true
          */
          runPreprocessor(sType: string, vSource: any | string | sap.ui.core.Element, bSync?: boolean): JQueryPromise<any> | any | string | sap.ui.core.Element;

          /**
           * Sets a new value for property <code>displayBlock</code>.Whether the CSS display should be set to
           * "block".Set this to "true" if the default display "inline-block" causes a vertical scrollbar with
           * Views that are set to 100% height.Do not set this to "true" if you want to display other content in
           * the same HTML parent on either side of the View (setting to "true" may push that other content to
           * the next/previous line).When called with a value of <code>null</code> or <code>undefined</code>, the
           * default value of the property will be restored.Default value is <code>false</code>.
           * @param bDisplayBlock New value for property <code>displayBlock</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setDisplayBlock(bDisplayBlock: boolean): sap.ui.core.mvc.View;

          /**
           * Sets a new value for property <code>height</code>.The heightWhen called with a value of
           * <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
           * @param sHeight New value for property <code>height</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setHeight(sHeight: any): sap.ui.core.mvc.View;

          /**
           * Sets a new value for property <code>viewName</code>.Name of the ViewWhen called with a value of
           * <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
           * @param sViewName New value for property <code>viewName</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setViewName(sViewName: string): sap.ui.core.mvc.View;

          /**
           * Sets a new value for property <code>width</code>.The widthWhen called with a value of
           * <code>null</code> or <code>undefined</code>, the default value of the property will be
           * restored.Default value is <code>100%</code>.
           * @param sWidth New value for property <code>width</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setWidth(sWidth: any): sap.ui.core.mvc.View;
        }
        /**
         * A View defined/constructed by JavaScript code.
         * @resource sap/ui/core/mvc/JSView.js
        */
        export class JSView extends sap.ui.core.mvc.View {

          /**
           * Flag for feature detection of asynchronous loading/rendering
           * @since 1.30
          */
          public asyncSupport: any;


          /**
           * Constructor for a new mvc/JSView.
           * @param sId id for the new control, generated automatically if no id is given
           * @param mSettings initial settings for the new control
          */
          constructor(sId: string, mSettings?: any);



          /**
           * A method to be implemented by JSViews, returning the View UI.While for declarative View types like
           * XMLView or JSONView the user interface definition is declared in a separate file,JSViews
           * programmatically construct the UI. This happens in the createContent method which every JSView needs
           * to implement.The View implementation can construct the complete UI in this method - or only return
           * the root control and create the rest of the UI lazily later on.
           * @returns a control or (typically) tree of controls representing the View user interface
          */
          createContent(): sap.ui.core.Control;


          /**
           * A method to be implemented by JSViews, returning the flag whether to prefixthe IDs of controls
           * automatically or not if the controls are created insidethe {@link
           * sap.ui.core.mvc.JSView#createContent} function. By default thisfeature is not activated.You can
           * overwrite this function and return true to activate the automaticprefixing.
           * @since 1.15.1
           * @returns true, if the controls IDs should be prefixed automatically
          */
          getAutoPrefixId(): boolean;

          /**
           * Returns a metadata object for class sap.ui.core.mvc.JSView.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;
        }
        /**
         * A View defined using (P)XML and HTML markup.
         * @resource sap/ui/core/mvc/XMLView.js
        */
        export class XMLView extends sap.ui.core.mvc.View {

          /**
           * Flag for feature detection of asynchronous loading/rendering
           * @since 1.30
          */
          public asyncSupport: any;


          /**
           * Constructor for a new mvc/XMLView.Accepts an object literal <code>mSettings</code> that defines
           * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
           * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
           * object.This class does not have its own settings, but all settings applicable to the base type{@link
           * sap.ui.core.mvc.View#constructor sap.ui.core.mvc.View} can be used.
           * @param sId id for the new control, generated automatically if no id is given
           * @param mSettings initial settings for the new control
          */
          constructor(sId: string, mSettings?: any);

          /**
           * Constructor for a new mvc/XMLView.Accepts an object literal <code>mSettings</code> that defines
           * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
           * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
           * object.This class does not have its own settings, but all settings applicable to the base type{@link
           * sap.ui.core.mvc.View#constructor sap.ui.core.mvc.View} can be used.
           * @param sId id for the new control, generated automatically if no id is given
           * @param mSettings initial settings for the new control
          */
          constructor(mSettings?: any);


          /**
           * Returns a metadata object for class sap.ui.core.mvc.XMLView.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Register a preprocessor for all views of a specific type.The preprocessor can be registered for
           * several stages of view initialization, for xml views these areeither the plain "xml" or the already
           * initialized "controls" , see {@link sap.ui.core.mvc.XMLView.PreprocessorType}.For each type one
           * preprocessor is executed. If there is a preprocessor passed to or activated at theview instance
           * already, that one is used. When several preprocessors are registered for one hook, it has to be
           * madesure, that they do not conflict when beeing processed serially.It can be either a module name as
           * string of an implementation of {@link sap.ui.core.mvc.View.Preprocessor} or afunction with a
           * signature according to {@link sap.ui.core.mvc.View.Preprocessor.process}.<strong>Note</strong>:
           * Preprocessors work only in async views and will be ignored when the view is instantiatedin sync mode
           * by default, as this could have unexpected side effects. You may override this behaviour by setting
           * thebSyncSupport flag to true.
           * @param sType the type of content to be processed
           * @param vPreprocessor module path of the preprocessor implementation or a preprocessor function
           * @param bSyncSupport declares if the vPreprocessor ensures safe sync processing. This means the
           * preprocessor will be executed		also for sync views. Please be aware that any kind of async
           * processing (like Promises, XHR, etc) may		break the view initialization and lead to unexpected
           * results.
           * @param bOnDemand ondemand preprocessor which enables developers to quickly activate the preprocessor
           * for a view,		by setting <code>preprocessors : { xml }</code>, for example.
           * @param mSettings optional configuration for preprocessor
          */
          registerPreprocessor(sType: string | sap.ui.core.mvc.XMLView.PreprocessorType, vPreprocessor: string | any, bSyncSupport: boolean, bOnDemand?: boolean, mSettings?: any): void;
        }
        /**
         * A View defined using JSON.
         * @resource sap/ui/core/mvc/JSONView.js
        */
        export class JSONView extends sap.ui.core.mvc.View {

          /**
           * Flag for feature detection of asynchronous loading/rendering
           * @since 1.30
          */
          public asyncSupport: any;


          /**
           * Constructor for a new mvc/JSONView.
           * @param sId id for the new control, generated automatically if no id is given
           * @param mSettings initial settings for the new control
          */
          constructor(sId: string, mSettings?: any);




          /**
           * Returns a metadata object for class sap.ui.core.mvc.JSONView.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;
        }
        /**
         * A view defined/constructed by declarative HTML.
         * @resource sap/ui/core/mvc/HTMLView.js
        */
        export class HTMLView extends sap.ui.core.mvc.View {

          /**
           * Flag for feature detection of asynchronous loading/rendering
           * @since 1.30
          */
          public asyncSupport: any;


          /**
           * Constructor for a new mvc/HTMLView.
           * @param sId id for the new control, generated automatically if no id is given
           * @param mSettings initial settings for the new control
          */
          constructor(sId: string, mSettings?: any);




          /**
           * Returns a metadata object for class sap.ui.core.mvc.HTMLView.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;
        }
        /**
         * A generic controller implementation for the UI5 Model-View-Controller concept.Can either be used as
         * a generic controller which is enriched on the fly with methodsand properties (see {@link
         * sap.ui.controller}) or  as a base class for typed controllers.
         * @resource sap/ui/core/mvc/Controller.js
        */
        export class Controller extends sap.ui.base.EventProvider {


          /**
           * Instantiates a (MVC-style) controller. Consumers should call the constructor only in thetyped
           * controller scenario. In the generic controller use case, they should use{@link sap.ui.controller}
           * instead.
           * @param sName The name of the controller to instantiate. If a controller is defined as real
           * sub-class,                                  the "arguments" of the sub-class constructor should be
           * given instead.
          */
          constructor(sName: string | any[]);



          /**
           * Returns an Element of the connected view with the given local ID.Views automatically prepend their
           * own ID as a prefix to created Elementsto make the IDs unique even in the case of multiple view
           * instances.This method helps to find an element by its local ID only.If no view is connected or if
           * the view doesn't contain an element withthe given local ID, undefined is returned.
           * @param sId View-local ID
           * @returns Element by its (view local) ID
          */
          byId(sId: string): sap.ui.core.Element;

          /**
           * Converts a view local ID to a globally unique one by prependingthe view ID.If no view is connected,
           * undefined is returned.
           * @param sId View-local ID
           * @returns Prefixed ID
          */
          createId(sId: string): string;


          /**
           * Returns a metadata object for class sap.ui.core.mvc.Controller.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Gets the component of the controller's viewIf there is no Component connected to the view or the
           * view is not connected to the controller,undefined is returned.
           * @since 1.23.0
           * @returns Component instance
          */
          getOwnerComponent(): sap.ui.core.Component;

          /**
           * Returns the view associated with this controller or undefined.
           * @returns View connected to this controller.
          */
          getView(): sap.ui.core.mvc.View;

          /**
           * This method is called every time the View is rendered, after the HTML is placed in the DOM-Tree. It
           * can beused to apply additional changes to the DOM after the Renderer has finished.(Even though this
           * method is declared as "abstract", it does not need to be defined in controllers, if themethod does
           * not exist, it will simply not be called.)
          */
          onAfterRendering(): void;

          /**
           * This method is called every time the View is rendered, before the Renderer is called and the HTML is
           * placed inthe DOM-Tree. It can be used to perform clean-up-tasks before re-rendering.(Even though
           * this method is declared as "abstract", it does not need to be defined in controllers, if themethod
           * does not exist, it will simply not be called.)
          */
          onBeforeRendering(): void;

          /**
           * This method is called upon desctuction of the View. The controller should perform its internal
           * destruction inthis hook. It is only called once per View instance, unlike the onBeforeRendering and
           * onAfterRenderinghooks.(Even though this method is declared as "abstract", it does not need to be
           * defined in controllers, if themethod does not exist, it will simply not be called.)
          */
          onExit(): void;

          /**
           * This method is called upon initialization of the View. The controller can perform its internal setup
           * inthis hook. It is only called once per View instance, unlike the onBeforeRendering and
           * onAfterRenderinghooks.(Even though this method is declared as "abstract", it does not need to be
           * defined in controllers, if themethod does not exist, it will simply not be called.)
          */
          onInit(): void;

          /**
           * Registers a callback module, which provides code enhancements for thelifecycle and event handler
           * functions of a specific controller. The codeenhancements are returned either in sync or async
           * mode.The extension provider module provides the <code>getControllerExtensions</code> functionwhich
           * returns either directly an array of objects or a Promise that returns an arrayof objects when it
           * resolves. These objects are object literals defining themethods and properties of the controller in
           * a similar way as {@link sap.ui.controller}.<b>Example for a callback module definition
           * (sync):</b><pre>sap.ui.define("my/custom/sync/ExtensionProvider", ['jquery.sap.global'],
           * function(jQuery) {  var ExtensionProvider = function() {}; 
           * ExtensionProvider.prototype.getControllerExtensions = function(sControllerName, sComponentId,
           * bAsync) {    if (!bAsync && sControllerName == "my.own.Controller") {      // IMPORTANT: only return
           * extensions for a specific controller      return [{        onInit: function() {          // Do
           * something here...        },        onAfterRendering: function() {          // Do something here...  
           *      },        onButtonClick: function(oEvent) {          // Handle the button click event        } 
           *     }    }];  };  return ExtensionProvider;}, true);</pre><b>Example for a callback module
           * definition (async):</b><pre>sap.ui.define("my/custom/async/ExtensionProvider",
           * ['jquery.sap.global'], function(jQuery) {  var ExtensionProvider = function() {}; 
           * ExtensionProvider.prototype.getControllerExtensions = function(sControllerName, sComponentId,
           * bAsync) {    if (bAsync && sControllerName == "my.own.Controller") {      // IMPORTANT:      // only
           * return a Promise for a specific controller since it      // requires the View/Controller and its
           * parents to run in async      // mode!      return new Promise(function(fnResolve, fnReject) {       
           * fnResolve([{          onInit: function() {            // Do something here...          },         
           * onAfterRendering: function() {            // Do something here...          },         
           * onButtonClick: function(oEvent) {            // Handle the button click event          }        }]);
           *      }    };  };  return ExtensionProvider;}, true);</pre>The lifecycle functions
           * <code>onInit</code>, <code>onExit</code>,<code>onBeforeRendering</code> and
           * <code>onAfterRendering</code>are added before or after the lifecycle functions of the
           * originalcontroller. The event handler functions, such as <code>onButtonClick</code>,are replacing
           * the original controller's function.When using an async extension provider you need to ensure that
           * theview is loaded in async mode.In both cases, return <code>undefined</code> if no controller
           * extension shall be applied.
           * @since 1.34.0
           * @param sExtensionProvider the module name of the extension provider
          */
          registerExtensionProvider(sExtensionProvider: string): void;
        }
        /**
         * A view defined in a template.
         * @resource sap/ui/core/mvc/TemplateView.js
        */
        export class TemplateView extends sap.ui.core.mvc.View {


          /**
           * Constructor for a new mvc/TemplateView.
           * @param sId id for the new control, generated automatically if no id is given
           * @param mSettings initial settings for the new control
          */
          constructor(sId: string, mSettings?: any);




          /**
           * Returns a metadata object for class sap.ui.core.mvc.TemplateView.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;
        }
      }
      namespace URI {
      }
      namespace Dock {
      }
      namespace tmpl {
        /**
         * Base Class for Template.
         * @resource sap/ui/core/tmpl/Template.js
        */
        export abstract class Template extends sap.ui.base.ManagedObject {


          /**
           * Creates and initializes a new template with the given <code>sId</code> andsettings.The set of
           * allowed entries in the <code>mSettings</code> object depends onthe concrete subclass and is
           * described there.Accepts an object literal <code>mSettings</code> that defines initialproperty
           * values, aggregated and associated objects as well as event handlers.See {@link
           * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
           * object.
           * @param sId optional id for the new template; generated automatically if           no non-empty id is
           * given Note: this can be omitted, no matter           whether <code>mSettings</code> will be given or
           * not!
           * @param mSettings optional map/JSON-object with initial settings for the           new component
           * instance
          */
          constructor(sId: string, mSettings?: any);



          /**
           * Returns the registered template for the given id, if any.
           * @param sId undefined
           * @returns the template for the given id
          */
          byId(sId: string): any;

          /**
           * Creates an anonymous TemplateControl for the Template.
           * @param sId the control ID
           * @param oContext the context for the renderer/templating
           * @param oView undefined
           * @returns the created control instance
          */
          createControl(sId: string, oContext: any, oView: sap.ui.core.mvc.View): sap.ui.core.tmpl.TemplateControl;

          /**
           * Declares a new control based on this template and returns the createdclass / constructor function.
           * The class is based on the information comingfrom the abstract functions <code>createMetadata</code>
           * and<code>createRenderer</code>.
           * @param sControl the fully qualified name of the control
           * @returns the created class / constructor function
          */
          declareControl(sControl: string): any;


          /**
           * Gets current value of property <code>content</code>.The Template definition as a String.
           * @returns Value of property <code>content</code>
          */
          getContent(): string;

          /**
          */
          getInterface(): sap.ui.base.Interface;

          /**
           * Returns a metadata object for class sap.ui.core.tmpl.Template.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * parses the given path and extracts the model and path
           * @param sPath the path
           * @returns the model and the path
          */
          parsePath(sPath: string): any;

          /**
           * Creates an anonymous TemplateControl for the Template and places the controlinto the specified DOM
           * element.
           * @param oRef the id or the DOM reference where to render the template
           * @param oContext The context to use to evaluate the Template. It will be applied as value for the
           * context property of the created control.
           * @param vPosition Describes the position where the control should be put into the container
           * @param bInline undefined
           * @returns the created control instance
          */
          placeAt(oRef: string | any, oContext: any, vPosition: string | number, bInline: boolean): sap.ui.core.tmpl.TemplateControl;

          /**
           * Sets a new value for property <code>content</code>.The Template definition as a String.When called
           * with a value of <code>null</code> or <code>undefined</code>, the default value of the property will
           * be restored.
           * @param sContent New value for property <code>content</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setContent(sContent: string): any;
        }
        /**
         * Represents a DOM element. It allows to use databinding for the properties and nested DOM attributes.
         * @resource sap/ui/core/tmpl/DOMElement.js
        */
        export class DOMElement extends sap.ui.core.Control {


          /**
           * Constructor for a new tmpl/DOMElement.Accepts an object literal <code>mSettings</code> that defines
           * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
           * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
           * object.
           * @param sId id for the new control, generated automatically if no id is given
           * @param mSettings initial settings for the new control
          */
          constructor(sId: string, mSettings?: any);



          /**
           * Adds some attribute to the aggregation <code>attributes</code>.
           * @param oAttribute the attribute to add; if empty, nothing is inserted
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          addAttribute(oAttribute: sap.ui.core.tmpl.DOMAttribute): sap.ui.core.tmpl.DOMElement;

          /**
           * Adds some element to the aggregation <code>elements</code>.
           * @param oElement the element to add; if empty, nothing is inserted
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          addElement(oElement: sap.ui.core.tmpl.DOMElement): sap.ui.core.tmpl.DOMElement;

          /**
           * Returns the value of a DOM attribute if available or undefined if the DOM attribute is not available
           * when using this method with the parameter name only.When using the method with the parameter name
           * and value the method acts as a setter and sets the value of a DOM attribute.In this case the return
           * value is the reference to this DOM element to support method chaining. If you pass null as value of
           * the attribute the attribute will be removed.
           * @param sName The name of the DOM attribute.
           * @param sValue The value of the DOM attribute. If the value is undefined the DOM attribute will be
           * removed.
           * @returns value of attribute or <code>this</code> when called as a setter
          */
          attr(sName: string, sValue: string): any;

          /**
           * Destroys all the attributes in the aggregation <code>attributes</code>.
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          destroyAttributes(): sap.ui.core.tmpl.DOMElement;

          /**
           * Destroys all the elements in the aggregation <code>elements</code>.
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          destroyElements(): sap.ui.core.tmpl.DOMElement;


          /**
           * Gets content of aggregation <code>attributes</code>.DOM attributes which are rendered as part of the
           * DOM element and bindable
          */
          getAttributes(): sap.ui.core.tmpl.DOMAttribute[];

          /**
           * Gets content of aggregation <code>elements</code>.Nested DOM elements to support nested bindable
           * structures
          */
          getElements(): sap.ui.core.tmpl.DOMElement[];

          /**
           * Returns a metadata object for class sap.ui.core.tmpl.DOMElement.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Gets current value of property <code>tag</code>.The HTML-tag of the DOM element which contains the
           * textDefault value is <code>span</code>.
           * @returns Value of property <code>tag</code>
          */
          getTag(): string;

          /**
           * Gets current value of property <code>text</code>.The text content of the DOM element
           * @returns Value of property <code>text</code>
          */
          getText(): string;

          /**
           * Checks for the provided <code>sap.ui.core.tmpl.DOMAttribute</code> in the aggregation
           * <code>attributes</code>.and returns its index if found or -1 otherwise.
           * @param oAttribute The attribute whose index is looked for
           * @returns The index of the provided control in the aggregation if found, or -1 otherwise
          */
          indexOfAttribute(oAttribute: sap.ui.core.tmpl.DOMAttribute): number;

          /**
           * Checks for the provided <code>sap.ui.core.tmpl.DOMElement</code> in the aggregation
           * <code>elements</code>.and returns its index if found or -1 otherwise.
           * @param oElement The element whose index is looked for
           * @returns The index of the provided control in the aggregation if found, or -1 otherwise
          */
          indexOfElement(oElement: sap.ui.core.tmpl.DOMElement): number;

          /**
           * Inserts a attribute into the aggregation <code>attributes</code>.
           * @param oAttribute the attribute to insert; if empty, nothing is inserted
           * @param iIndex the <code>0</code>-based index the attribute should be inserted at; for             a
           * negative value of <code>iIndex</code>, the attribute is inserted at position 0; for a value         
           *    greater than the current size of the aggregation, the attribute is inserted at             the
           * last position
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          insertAttribute(oAttribute: sap.ui.core.tmpl.DOMAttribute, iIndex: number): sap.ui.core.tmpl.DOMElement;

          /**
           * Inserts a element into the aggregation <code>elements</code>.
           * @param oElement the element to insert; if empty, nothing is inserted
           * @param iIndex the <code>0</code>-based index the element should be inserted at; for             a
           * negative value of <code>iIndex</code>, the element is inserted at position 0; for a value           
           *  greater than the current size of the aggregation, the element is inserted at             the last
           * position
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          insertElement(oElement: sap.ui.core.tmpl.DOMElement, iIndex: number): sap.ui.core.tmpl.DOMElement;

          /**
           * Removes all the controls from the aggregation <code>attributes</code>.Additionally, it unregisters
           * them from the hosting UIArea.
           * @returns An array of the removed elements (might be empty)
          */
          removeAllAttributes(): sap.ui.core.tmpl.DOMAttribute[];

          /**
           * Removes all the controls from the aggregation <code>elements</code>.Additionally, it unregisters
           * them from the hosting UIArea.
           * @returns An array of the removed elements (might be empty)
          */
          removeAllElements(): sap.ui.core.tmpl.DOMElement[];

          /**
           * Removes the DOM attribute for the given name and returns the reference to this DOM element to
           * support method chaining.
           * @param sName The name of the DOM attribute.
          */
          removeAttr(sName: string): sap.ui.core.tmpl.DOMElement;

          /**
           * Removes a attribute from the aggregation <code>attributes</code>.
           * @param vAttribute The attribute to remove or its index or id
           * @returns The removed attribute or <code>null</code>
          */
          removeAttribute(vAttribute: number | string | sap.ui.core.tmpl.DOMAttribute): sap.ui.core.tmpl.DOMAttribute;

          /**
           * Removes a element from the aggregation <code>elements</code>.
           * @param vElement The element to remove or its index or id
           * @returns The removed element or <code>null</code>
          */
          removeElement(vElement: number | string | sap.ui.core.tmpl.DOMElement): sap.ui.core.tmpl.DOMElement;

          /**
           * Sets a new value for property <code>tag</code>.The HTML-tag of the DOM element which contains the
           * textWhen called with a value of <code>null</code> or <code>undefined</code>, the default value of
           * the property will be restored.Default value is <code>span</code>.
           * @param sTag New value for property <code>tag</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setTag(sTag: string): sap.ui.core.tmpl.DOMElement;

          /**
           * Sets a new value for property <code>text</code>.The text content of the DOM elementWhen called with
           * a value of <code>null</code> or <code>undefined</code>, the default value of the property will be
           * restored.
           * @param sText New value for property <code>text</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setText(sText: string): sap.ui.core.tmpl.DOMElement;
        }
        /**
         * Represents a DOM attribute of a DOM element.
         * @resource sap/ui/core/tmpl/DOMAttribute.js
        */
        export class DOMAttribute extends sap.ui.core.Element {


          /**
           * Constructor for a new tmpl/DOMAttribute.Accepts an object literal <code>mSettings</code> that
           * defines initialproperty values, aggregated and associated objects as well as event handlers.See
           * {@link sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the
           * settings object.
           * @param sId id for the new control, generated automatically if no id is given
           * @param mSettings initial settings for the new control
          */
          constructor(sId: string, mSettings?: any);




          /**
           * Returns a metadata object for class sap.ui.core.tmpl.DOMAttribute.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Gets current value of property <code>name</code>.Name of the DOM attribute
           * @returns Value of property <code>name</code>
          */
          getName(): string;

          /**
           * Gets current value of property <code>value</code>.Value of the DOM attribute
           * @returns Value of property <code>value</code>
          */
          getValue(): string;

          /**
           * Sets a new value for property <code>name</code>.Name of the DOM attributeWhen called with a value of
           * <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
           * @param sName New value for property <code>name</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setName(sName: string): sap.ui.core.tmpl.DOMAttribute;

          /**
           * Sets a new value for property <code>value</code>.Value of the DOM attributeWhen called with a value
           * of <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
           * @param sValue New value for property <code>value</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setValue(sValue: string): sap.ui.core.tmpl.DOMAttribute;
        }
        /**
         * This is the base class for all template controls. Template controls are declared based on templates.
         * @resource sap/ui/core/tmpl/TemplateControl.js
        */
        export class TemplateControl extends sap.ui.core.Control {


          /**
           * Constructor for a new tmpl/TemplateControl.Accepts an object literal <code>mSettings</code> that
           * defines initialproperty values, aggregated and associated objects as well as event handlers.See
           * {@link sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the
           * settings object.
           * @param sId id for the new control, generated automatically if no id is given
           * @param mSettings initial settings for the new control
          */
          constructor(sId: string, mSettings?: any);



          /**
           * Attaches event handler <code>fnFunction</code> to the <code>afterRendering</code> event of this
           * <code>sap.ui.core.tmpl.TemplateControl</code>.When called, the context of the event handler (its
           * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
           * to this <code>sap.ui.core.tmpl.TemplateControl</code> itself.Fired when the Template Control has
           * been (re-)rendered and its HTML is present in the DOM.
           * @param oData An application-specific payload object that will be passed to the event handler along
           * with the event object when firing the event
           * @param fnFunction The function to be called when the event occurs
           * @param oListener Context object to call the event handler with. Defaults to this
           * <code>sap.ui.core.tmpl.TemplateControl</code> itself
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          attachAfterRendering(oData: any, fnFunction: any, oListener?: any): sap.ui.core.tmpl.TemplateControl;

          /**
           * Attaches event handler <code>fnFunction</code> to the <code>beforeRendering</code> event of this
           * <code>sap.ui.core.tmpl.TemplateControl</code>.When called, the context of the event handler (its
           * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
           * to this <code>sap.ui.core.tmpl.TemplateControl</code> itself.Fired before this Template Control is
           * re-rendered. Use to unbind event handlers from HTML elements etc.
           * @param oData An application-specific payload object that will be passed to the event handler along
           * with the event object when firing the event
           * @param fnFunction The function to be called when the event occurs
           * @param oListener Context object to call the event handler with. Defaults to this
           * <code>sap.ui.core.tmpl.TemplateControl</code> itself
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          attachBeforeRendering(oData: any, fnFunction: any, oListener?: any): sap.ui.core.tmpl.TemplateControl;

          /**
           * Creates a pseudo binding for a aggregation to get notified once the propertychanges to invalidate
           * the control and trigger a re-rendering.
           * @param sPath the binding path
           * @returns the value of the path
          */
          bindList(sPath: string): any;

          /**
           * Creates a pseudo binding for a property to get notified once the propertychanges to invalidate the
           * control and trigger a re-rendering.
           * @param sPath the binding path
           * @returns the value of the path
          */
          bindProp(sPath: string): any;

          /**
           * compiles (creates and registers) a new control
           * @param mSettings the settings for the new control
           * @param sParentPath the parent path for the control
           * @param bDoNotAdd if true, then the control will not be         added to the _controls aggregation
           * @param oView undefined
           * @returns new control instance
          */
          createControl(mSettings: any, sParentPath: string, bDoNotAdd: boolean, oView: sap.ui.core.mvc.View): sap.ui.core.Control;

          /**
           * compiles (creates and registers) a new DOM element
           * @param mSettings the settings for the new DOM element
           * @param sParentPath the parent path for the DOM element
           * @param bDoNotAdd if true, then the control will not be         added to the _controls aggregation
           * @returns new DOM element instance
          */
          createDOMElement(mSettings: any, sParentPath?: string, bDoNotAdd?: boolean): sap.ui.core.Control;

          /**
           * Detaches event handler <code>fnFunction</code> from the <code>afterRendering</code> event of this
           * <code>sap.ui.core.tmpl.TemplateControl</code>.The passed function and listener object must match the
           * ones used for event registration.
           * @param fnFunction The function to be called, when the event occurs
           * @param oListener Context object on which the given function had to be called
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          detachAfterRendering(fnFunction: any, oListener: any): sap.ui.core.tmpl.TemplateControl;

          /**
           * Detaches event handler <code>fnFunction</code> from the <code>beforeRendering</code> event of this
           * <code>sap.ui.core.tmpl.TemplateControl</code>.The passed function and listener object must match the
           * ones used for event registration.
           * @param fnFunction The function to be called, when the event occurs
           * @param oListener Context object on which the given function had to be called
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          detachBeforeRendering(fnFunction: any, oListener: any): sap.ui.core.tmpl.TemplateControl;


          /**
           * Fires event <code>afterRendering</code> to attached listeners.
           * @param mArguments The arguments to pass along with the event
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          fireAfterRendering(mArguments: any): sap.ui.core.tmpl.TemplateControl;

          /**
           * Fires event <code>beforeRendering</code> to attached listeners.
           * @param mArguments The arguments to pass along with the event
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          fireBeforeRendering(mArguments: any): sap.ui.core.tmpl.TemplateControl;

          /**
           * Gets current value of property <code>context</code>.The context is a data object. It can be used for
           * default template expressions. A change of the context object leads to a re-rendering whereas a
           * change of a nested property of the context object doesn't. By default the context is an empty
           * object.
           * @returns Value of property <code>context</code>
          */
          getContext(): any;

          /**
           * Returns a metadata object for class sap.ui.core.tmpl.TemplateControl.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * ID of the element which is the current target of the association <code>template</code>, or
           * <code>null</code>.
          */
          getTemplate(): any;

          /**
           * Returns the instance specific renderer for an anonymous template control.
           * @returns the instance specific renderer function
          */
          getTemplateRenderer(): any;

          /**
           * checks whether the control is inline or not
           * @returns flag, whether to control is inline or not
          */
          isInline(): boolean;

          /**
           * Sets a new value for property <code>context</code>.The context is a data object. It can be used for
           * default template expressions. A change of the context object leads to a re-rendering whereas a
           * change of a nested property of the context object doesn't. By default the context is an empty
           * object.When called with a value of <code>null</code> or <code>undefined</code>, the default value of
           * the property will be restored.
           * @param oContext New value for property <code>context</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setContext(oContext: any): sap.ui.core.tmpl.TemplateControl;

          /**
           * Sets the associated <code>template</code>.
           * @param oTemplate ID of an element which becomes the new target of this template association;
           * alternatively, an element instance may be given
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setTemplate(oTemplate: any | any): sap.ui.core.tmpl.TemplateControl;

          /**
           * Sets the instance specific renderer for an anonymous template control.
           * @param fnRenderer the instance specific renderer function
           * @returns <code>this</code> to allow method chaining
          */
          setTemplateRenderer(fnRenderer: any): any;
        }
        /**
         * The class for Handlebars Templates.
         * @resource sap/ui/core/tmpl/HandlebarsTemplate.js
        */
        export abstract class HandlebarsTemplate extends sap.ui.core.tmpl.Template {


          /**
           * Creates and initializes a new handlebars template with the given <code>sId</code>and settings.The
           * set of allowed entries in the <code>mSettings</code> object depends onthe concrete subclass and is
           * described there.
           * @param sId optional id for the new template; generated automatically if           no non-empty id is
           * given Note: this can be omitted, no matter           whether <code>mSettings</code> will be given or
           * not!
           * @param mSettings optional map/JSON-object with initial settings for the           new component
           * instance
          */
          constructor(sId: string, mSettings?: any);




          /**
           * Returns a metadata object for class sap.ui.core.tmpl.HandlebarsTemplate.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;
        }
      }
      namespace util {
        namespace File {

          /**
           * <p>Triggers a download / save action of the given file.</p><p>There are limitations for this feature
           * in some browsers:<p><p><b>Internet Explorer 8 / 9</b><br>Some file extensions on some operating
           * systems are not working due to a bug in IE.Therefore 'txt' will be used as file extension if the
           * problem is occurring.</p><p><b>Safari (OS X / iOS)</b><br>A new window/tab will be opened. In OS X
           * the user has to manually save the file (CMD + S), choose "page source" and specify a filename.In iOS
           * the content can be opened in another app (Mail, Notes, ...) or copied to the clipboard.In case the
           * popup blocker prevents this action, an error will be thrown which can be used to notify the user to
           * disable it.</p><p><b>Android Browser</b><br>Not supported</p>
           * @param sData file content
           * @param sFileName file name
           * @param sFileExtension file extension
           * @param sMimeType file mime-type
           * @param sCharset file charset
          */
          function save(sData: string, sFileName: string, sFileExtension: string, sMimeType: string, sCharset: string): void;
        }
        namespace serializer {
          namespace delegate {
            /**
             * XML serializer delegate class.
             * @resource sap/ui/core/util/serializer/delegate/XML.js
            */
            export class XML extends sap.ui.core.util.serializer.delegate.Delegate {


              /**
               * XML serializer delegate class. Called by the serializer instance.
               * @param sDefaultXmlNamespace defines the default XML namespace
               * @param fnGetControlId delegate function which returns the control id
               * @param fnGetEventHandlerName delegate function which returns the event handler name
               * @param fnMemorizePackage a delegate function to memorize the control packages
              */
              constructor(sDefaultXmlNamespace: string, fnGetControlId?: any, fnGetEventHandlerName?: any, fnMemorizePackage?: any);




              /**
               * Returns a metadata object for class sap.ui.core.util.serializer.delegate.XML.
               * @returns Metadata object describing this class
              */
              getMetadata(): sap.ui.base.Metadata;
            }
            /**
             * HTML serializer delegate class.
             * @resource sap/ui/core/util/serializer/delegate/HTML.js
            */
            export class HTML extends sap.ui.core.util.serializer.delegate.Delegate {


              /**
               * HTML serializer delegate class. Called by the serializer instance.
               * @param fnGetControlId delegate function which returns the control id
               * @param fnGetEventHandlerName delegate function which returns the event handler name
              */
              constructor(fnGetControlId: any, fnGetEventHandlerName?: any);




              /**
               * Returns a metadata object for class sap.ui.core.util.serializer.delegate.HTML.
               * @returns Metadata object describing this class
              */
              getMetadata(): sap.ui.base.Metadata;
            }
            /**
             * Abstract serializer delegate class.
             * @resource sap/ui/core/util/serializer/delegate/Delegate.js
            */
            export abstract class Delegate extends sap.ui.base.EventProvider {


              /**
               * Abstract serializer delegate class. All delegates must extend from this class and implement the
               * abstract methods.
              */
              constructor();




              /**
               * Returns a metadata object for class sap.ui.core.util.serializer.delegate.Delegate.
               * @returns Metadata object describing this class
              */
              getMetadata(): sap.ui.base.Metadata;
            }
          }
          /**
           * Serializer class.
           * @resource sap/ui/core/util/serializer/Serializer.js
          */
          export class Serializer extends sap.ui.base.EventProvider {


            /**
             * Serializer class. Iterates over all controls and call a given serializer delegate.
             * @param oRootControl the root control to serialize
             * @param serializeDelegate the serializer delegate. Has to implement start/middle/end methods.
             * @param bSkipRoot whether to skip the root node or not
             * @param fnSkipAggregations whether to skip aggregations
             * @param fnSkipElement whether to skip an element
            */
            constructor(oRootControl: sap.ui.core.Control | sap.ui.core.UIArea, serializeDelegate: any, bSkipRoot: boolean, fnSkipAggregations: any, fnSkipElement: any);




            /**
             * Returns a metadata object for class sap.ui.core.util.serializer.Serializer.
             * @returns Metadata object describing this class
            */
            getMetadata(): sap.ui.base.Metadata;
          }
          /**
           * ViewSerializer class.
           * @resource sap/ui/core/util/serializer/ViewSerializer.js
          */
          export class ViewSerializer extends sap.ui.base.EventProvider {


            /**
             * View serializer class. Iterates over all controls and serializes all found views by calling the
             * corresponding view type serializer.
             * @param oRootControl the root control to serialize
             * @param oWindow the window object. Default is the window object the instance of the serializer is
             * running in.
             * @param sDefaultXmlNamespace defines the default xml namespace
            */
            constructor(oRootControl: sap.ui.core.Control | sap.ui.core.UIArea, oWindow?: any, sDefaultXmlNamespace?: string);




            /**
             * Returns a metadata object for class sap.ui.core.util.serializer.ViewSerializer.
             * @returns Metadata object describing this class
            */
            getMetadata(): sap.ui.base.Metadata;
          }
          /**
           * XMLViewSerializer class.
           * @resource sap/ui/core/util/serializer/XMLViewSerializer.js
          */
          export class XMLViewSerializer extends sap.ui.base.EventProvider {


            /**
             * XML view serializer class. Serializes a given view.
             * @param oView the view to serialize
             * @param oWindow the window object. Default is the window object the instance of the serializer is
             * running in
             * @param sDefaultXmlNamespace defines the default XML namespace
             * @param fnGetControlId delegate function which returns the control id
             * @param fnGetEventHandlerName delegate function which returns the event handler name
            */
            constructor(oView: sap.ui.core.mvc.XMLView, oWindow: any, sDefaultXmlNamespace: string, fnGetControlId: any, fnGetEventHandlerName: any);




            /**
             * Returns a metadata object for class sap.ui.core.util.serializer.XMLViewSerializer.
             * @returns Metadata object describing this class
            */
            getMetadata(): sap.ui.base.Metadata;
          }
          /**
           * HTMLViewSerializer class.
           * @resource sap/ui/core/util/serializer/HTMLViewSerializer.js
          */
          export class HTMLViewSerializer extends sap.ui.base.EventProvider {


            /**
             * HTML view serializer class. Serializes a given view.
             * @param oView the view to serialize
             * @param oWindow the window object. Default is the window object the instance of the serializer is
             * running in
             * @param fnGetControlId delegate function which returns the control id
             * @param fnGetEventHandlerName delegate function which returns the event handler name
            */
            constructor(oView: sap.ui.core.mvc.HTMLView, oWindow: any, fnGetControlId: any, fnGetEventHandlerName: any);




            /**
             * Returns a metadata object for class sap.ui.core.util.serializer.HTMLViewSerializer.
             * @returns Metadata object describing this class
            */
            getMetadata(): sap.ui.base.Metadata;
          }
        }
        namespace XMLPreprocessor {
          /**
           * Context interface provided by XML template processing as an additional firstargument to any
           * formatter function which opts in to this mechanism. Candidates forsuch formatter functions are all
           * those used in binding expressions which areevaluated during XML template processing, including those
           * used inside templateinstructions like <code>&lt;template:if></code>. The formatter function needs to
           * bemarked with a property <code>requiresIContext = true</code> to express that itrequires this
           * extended signature (compared to ordinary formatter functions). Theusual arguments are provided after
           * the first one (currently: the raw value from themodel).This interface provides callback functions to
           * access the model and path  which areneeded to process OData V4 annotations. It initially offers a
           * subset of methodsfrom {@link sap.ui.model.Context} so that formatters might also be called with
           * acontext object for convenience, e.g. outside of XML template processing (see belowfor an exception
           * to this rule).<b>Example:</b> Suppose you have a formatter function called "foo" like belowand it is
           * used within an XML template like<code>&lt;template:if test="{path: '...', formatter:
           * 'foo'}"></code>.In this case <code>foo</code> is called with arguments<code>oInterface,
           * vRawValue</code> such that<code>oInterface.getModel().getObject(oInterface.getPath()) ===
           * vRawValue</code>holds.<pre>window.foo = function (oInterface, vRawValue) {    //TODO
           * ...};window.foo.requiresIContext = true;</pre><b>Composite Binding Examples:</b> Suppose you have
           * the same formatter function andit is used in a composite binding like <code>&lt;Text text="{path:
           * 'Label',formatter: 'foo'}: {path: 'Value', formatter: 'foo'}"/></code>.In this case
           * <code>oInterface.getPath()</code> refers to ".../Label" in the 1st calland ".../Value" in the 2nd
           * call. This means each formatter call knows which part ofthe composite binding it belongs to and
           * behaves just as if it was an ordinarybinding.Suppose your formatter is not used within a part of the
           * composite binding, but atthe root of the composite binding in order to aggregate all parts like
           * <code>&lt;Text text="{parts: [{path: 'Label'}, {path: 'Value'}], formatter: 'foo'}"/></code>. In
           * this case <code>oInterface.getPath(0)</code> refers to ".../Label"
           * and<code>oInterface.getPath(1)</code> refers to ".../Value". This means, the rootformatter can
           * access the ith part of the composite binding at will (since 1.31.0);see also {@link #.getInterface
           * getInterface}.The function <code>foo</code> is called with arguments such that
           * <code>oInterface.getModel(i).getObject(oInterface.getPath(i)) === arguments[i + 1]</code>holds.To
           * distinguish those two use cases, just check whether<code>oInterface.getModel() === undefined</code>,
           * in which case the formatter iscalled on root level of a composite binding. To find out the number of
           * parts, probefor the smallest non-negative integer where<code>oInterface.getModel(i) ===
           * undefined</code>.This additional functionality is, of course, not available from{@link
           * sap.ui.model.Context}, i.e. such formatters MUST be called with an instanceof this context
           * interface.
           * @resource sap/ui/core/util/XMLPreprocessor.js
          */
          interface IContext {



            /**
             * Returns a context interface for the indicated part in case of the root formatterof a composite
             * binding. The new interface provides access to the originalsettings, but only to the model and path
             * of the indicated part:<pre>this.getInterface(i).getSetting(sName) ===
             * this.getSetting(sName);this.getInterface(i).getModel() ===
             * this.getModel(i);this.getInterface(i).getPath() === this.getPath(i);</pre>If a path is given, the
             * new interface points to the resolved path as follows:<pre>this.getInterface(i, "foo/bar").getPath()
             * === this.getPath(i) + "/foo/bar";this.getInterface(i, "/absolute/path").getPath() ===
             * "/absolute/path";</pre>A formatter which is not at the root level of a composite binding can
             * alsoprovide a path, but must not provide an index:<pre>this.getInterface("foo/bar").getPath() ===
             * this.getPath() + "/foo/bar";this.getInterface("/absolute/path").getPath() ===
             * "/absolute/path";</pre>Note that at least one argument must be present.
             * @since 1.31.0
             * @param iPart index of part in case of the root formatter of a composite binding
             * @param sPath a path, interpreted relative to <code>this.getPath(iPart)</code>
             * @returns the context interface related to the indicated part
            */
            getInterface(iPart: number, sPath?: string): sap.ui.core.util.XMLPreprocessor.IContext;

            /**
             * Returns the model related to the current formatter call.
             * @param iPart index of part in case of the root formatter of a composite binding  (since 1.31.0)
             * @returns the model related to the current formatter call, or (since 1.31.0)  <code>undefined</code>
             * in case of a root formatter if no <code>iPart</code> is  given or if <code>iPart</code> is out of
             * range
            */
            getModel(iPart: number): sap.ui.model.Model;

            /**
             * Returns the absolute path related to the current formatter call.
             * @param iPart index of part in case of the root formatter of a composite binding  (since 1.31.0)
             * @returns the absolute path related to the current formatter call, or (since 1.31.0) 
             * <code>undefined</code> in case of a root formatter if no <code>iPart</code> is  given or if
             * <code>iPart</code> is out of range
            */
            getPath(iPart: number): string;

            /**
             * Returns the value of the setting with the given name which was provided to theXML template
             * processing.
             * @param sName the name of the setting
             * @returns the value of the setting
            */
            getSetting(sName: string): any;
          }
        }
        /**
         * Export provides the possibility to generate a list of data in a specific format / type, e.g. CSV to
         * use it in other programs / applications.
         * @resource sap/ui/core/util/Export.js
        */
        export class Export extends sap.ui.core.Control {


          /**
           * Constructor for a new Export.Accepts an object literal <code>mSettings</code> that defines
           * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
           * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
           * object.
           * @param sId id for the new control, generated automatically if no id is given
           * @param mSettings initial settings for the new control
          */
          constructor(sId: string, mSettings?: any);



          /**
           * Adds some column to the aggregation <code>columns</code>.
           * @param oColumn the column to add; if empty, nothing is inserted
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          addColumn(oColumn: sap.ui.core.util.ExportColumn): sap.ui.core.util.Export;

          /**
           * Adds some row to the aggregation <code>rows</code>.
           * @param oRow the row to add; if empty, nothing is inserted
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          addRow(oRow: sap.ui.core.util.ExportRow): sap.ui.core.util.Export;

          /**
           * Binds aggregation <code>columns</code> to model data.See {@link
           * sap.ui.base.ManagedObject#bindAggregation ManagedObject.bindAggregation} for a detailed description
           * of the possible properties of <code>oBindingInfo</code>.
           * @param oBindingInfo The binding information
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          bindColumns(oBindingInfo: any): sap.ui.core.util.Export;

          /**
           * Binds aggregation <code>rows</code> to model data.See {@link
           * sap.ui.base.ManagedObject#bindAggregation ManagedObject.bindAggregation} for a detailed description
           * of the possible properties of <code>oBindingInfo</code>.
           * @param oBindingInfo The binding information
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          bindRows(oBindingInfo: any): sap.ui.core.util.Export;

          /**
           * Destroys all the columns in the aggregation <code>columns</code>.
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          destroyColumns(): sap.ui.core.util.Export;

          /**
           * Destroys the exportType in the aggregation <code>exportType</code>.
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          destroyExportType(): sap.ui.core.util.Export;

          /**
           * Destroys all the rows in the aggregation <code>rows</code>.
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          destroyRows(): sap.ui.core.util.Export;


          /**
           * Generates the file content and returns a Promisewith the instance as context (this).<br>The promise
           * will be resolved with the generated contentas a string.<p><b>Please note: The return value was
           * changed from jQuery Promises to standard ES6 Promises.jQuery specific Promise methods ('done',
           * 'fail', 'always', 'pipe' and 'state') are still available but should not be used.Please use only the
           * standard methods 'then' and 'catch'!</b></p>
           * @returns Promise object
          */
          generate(): JQueryPromise<any>;

          /**
           * Gets content of aggregation <code>columns</code>.Columns for the Export.
          */
          getColumns(): sap.ui.core.util.ExportColumn[];

          /**
           * Gets content of aggregation <code>exportType</code>.Type that generates the content.
          */
          getExportType(): sap.ui.core.util.ExportType;

          /**
           * Returns a metadata object for class sap.ui.core.util.Export.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Gets content of aggregation <code>rows</code>.Rows of the Export.
          */
          getRows(): sap.ui.core.util.ExportRow[];

          /**
           * Checks for the provided <code>sap.ui.core.util.ExportColumn</code> in the aggregation
           * <code>columns</code>.and returns its index if found or -1 otherwise.
           * @param oColumn The column whose index is looked for
           * @returns The index of the provided control in the aggregation if found, or -1 otherwise
          */
          indexOfColumn(oColumn: sap.ui.core.util.ExportColumn): number;

          /**
           * Checks for the provided <code>sap.ui.core.util.ExportRow</code> in the aggregation
           * <code>rows</code>.and returns its index if found or -1 otherwise.
           * @param oRow The row whose index is looked for
           * @returns The index of the provided control in the aggregation if found, or -1 otherwise
          */
          indexOfRow(oRow: sap.ui.core.util.ExportRow): number;

          /**
           * Inserts a column into the aggregation <code>columns</code>.
           * @param oColumn the column to insert; if empty, nothing is inserted
           * @param iIndex the <code>0</code>-based index the column should be inserted at; for             a
           * negative value of <code>iIndex</code>, the column is inserted at position 0; for a value            
           * greater than the current size of the aggregation, the column is inserted at             the last
           * position
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          insertColumn(oColumn: sap.ui.core.util.ExportColumn, iIndex: number): sap.ui.core.util.Export;

          /**
           * Inserts a row into the aggregation <code>rows</code>.
           * @param oRow the row to insert; if empty, nothing is inserted
           * @param iIndex the <code>0</code>-based index the row should be inserted at; for             a
           * negative value of <code>iIndex</code>, the row is inserted at position 0; for a value            
           * greater than the current size of the aggregation, the row is inserted at             the last
           * position
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          insertRow(oRow: sap.ui.core.util.ExportRow, iIndex: number): sap.ui.core.util.Export;

          /**
           * Removes all the controls from the aggregation <code>columns</code>.Additionally, it unregisters them
           * from the hosting UIArea.
           * @returns An array of the removed elements (might be empty)
          */
          removeAllColumns(): sap.ui.core.util.ExportColumn[];

          /**
           * Removes all the controls from the aggregation <code>rows</code>.Additionally, it unregisters them
           * from the hosting UIArea.
           * @returns An array of the removed elements (might be empty)
          */
          removeAllRows(): sap.ui.core.util.ExportRow[];

          /**
           * Removes a column from the aggregation <code>columns</code>.
           * @param vColumn The column to remove or its index or id
           * @returns The removed column or <code>null</code>
          */
          removeColumn(vColumn: number | string | sap.ui.core.util.ExportColumn): sap.ui.core.util.ExportColumn;

          /**
           * Removes a row from the aggregation <code>rows</code>.
           * @param vRow The row to remove or its index or id
           * @returns The removed row or <code>null</code>
          */
          removeRow(vRow: number | string | sap.ui.core.util.ExportRow): sap.ui.core.util.ExportRow;

          /**
           * Generates the file content, triggers a download / save action andreturns a Promise with the instance
           * as context (this).<br>The promise will be resolved with the generated contentas a string.<p><b>For
           * information about browser support, see <code>sap.ui.core.util.File.save</code></b></p><p><b>Please
           * note: The return value was changed from jQuery Promises to standard ES6 Promises.jQuery specific
           * Promise methods ('done', 'fail', 'always', 'pipe' and 'state') are still available but should not be
           * used.Please use only the standard methods 'then' and 'catch'!</b></p>
           * @param sFileName file name, defaults to 'data'
           * @returns Promise object
          */
          saveFile(sFileName: string): JQueryPromise<any>;

          /**
           * Sets the aggregated <code>exportType</code>.
           * @param oExportType The exportType to set
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setExportType(oExportType: sap.ui.core.util.ExportType): sap.ui.core.util.Export;

          /**
           * Unbinds aggregation <code>columns</code> from model data.
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          unbindColumns(): sap.ui.core.util.Export;

          /**
           * Unbinds aggregation <code>rows</code> from model data.
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          unbindRows(): sap.ui.core.util.Export;
        }
        /**
         * Internally used in {@link sap.ui.core.util.Export Export}.
         * @resource sap/ui/core/util/ExportRow.js
        */
        export class ExportRow extends sap.ui.base.ManagedObject {


          /**
           * Constructor for a new ExportRow.Accepts an object literal <code>mSettings</code> that defines
           * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
           * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
           * object.
           * @param sId id for the new control, generated automatically if no id is given
           * @param mSettings initial settings for the new control
          */
          constructor(sId: string, mSettings?: any);



          /**
           * Adds some cell to the aggregation <code>cells</code>.
           * @param oCell the cell to add; if empty, nothing is inserted
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          addCell(oCell: sap.ui.core.util.ExportCell): sap.ui.core.util.ExportRow;

          /**
           * Destroys all the cells in the aggregation <code>cells</code>.
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          destroyCells(): sap.ui.core.util.ExportRow;


          /**
           * Gets content of aggregation <code>cells</code>.Cells for the Export.
          */
          getCells(): sap.ui.core.util.ExportCell[];

          /**
           * Returns a metadata object for class sap.ui.core.util.ExportRow.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Checks for the provided <code>sap.ui.core.util.ExportCell</code> in the aggregation
           * <code>cells</code>.and returns its index if found or -1 otherwise.
           * @param oCell The cell whose index is looked for
           * @returns The index of the provided control in the aggregation if found, or -1 otherwise
          */
          indexOfCell(oCell: sap.ui.core.util.ExportCell): number;

          /**
           * Inserts a cell into the aggregation <code>cells</code>.
           * @param oCell the cell to insert; if empty, nothing is inserted
           * @param iIndex the <code>0</code>-based index the cell should be inserted at; for             a
           * negative value of <code>iIndex</code>, the cell is inserted at position 0; for a value            
           * greater than the current size of the aggregation, the cell is inserted at             the last
           * position
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          insertCell(oCell: sap.ui.core.util.ExportCell, iIndex: number): sap.ui.core.util.ExportRow;

          /**
           * Removes all the controls from the aggregation <code>cells</code>.Additionally, it unregisters them
           * from the hosting UIArea.
           * @returns An array of the removed elements (might be empty)
          */
          removeAllCells(): sap.ui.core.util.ExportCell[];

          /**
           * Removes a cell from the aggregation <code>cells</code>.
           * @param vCell The cell to remove or its index or id
           * @returns The removed cell or <code>null</code>
          */
          removeCell(vCell: number | string | sap.ui.core.util.ExportCell): sap.ui.core.util.ExportCell;
        }
        /**
         * Contains content that can be used to export data. Used in {@link sap.ui.core.util.ExportColumn
         * ExportColumn} / {@link sap.ui.core.util.Export Export}.
         * @resource sap/ui/core/util/ExportCell.js
        */
        export class ExportCell extends sap.ui.core.Element {


          /**
           * Constructor for a new ExportCell.Accepts an object literal <code>mSettings</code> that defines
           * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
           * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
           * object.
           * @param sId id for the new control, generated automatically if no id is given
           * @param mSettings initial settings for the new control
          */
          constructor(sId: string, mSettings?: any);




          /**
           * Gets current value of property <code>content</code>.Cell content.
           * @returns Value of property <code>content</code>
          */
          getContent(): string;

          /**
           * Returns a metadata object for class sap.ui.core.util.ExportCell.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Sets a new value for property <code>content</code>.Cell content.When called with a value of
           * <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
           * @param sContent New value for property <code>content</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setContent(sContent: string): sap.ui.core.util.ExportCell;
        }
        /**
         * Base export type. Subclasses can be used for {@link sap.ui.core.util.Export Export}.
         * @resource sap/ui/core/util/ExportType.js
        */
        export class ExportType extends sap.ui.base.ManagedObject {


          /**
           * Constructor for a new ExportType.Accepts an object literal <code>mSettings</code> that defines
           * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
           * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
           * object.
           * @param sId id for the new control, generated automatically if no id is given
           * @param mSettings initial settings for the new control
          */
          constructor(sId: string, mSettings?: any);



          /**
           * Handles the generation process of the file.<br>
           * @param oExport export instance
           * @returns content
          */
          _generate(oExport: sap.ui.core.util.Export): string;

          /**
           * Creates a cell "generator" (inspired by ES6 Generators)
           * @returns generator
          */
          cellGenerator(): any;

          /**
           * Creates a column "generator" (inspired by ES6 Generators)
           * @returns generator
          */
          columnGenerator(): any;


          /**
           * Generates the file content.<br>Should be implemented by the individual types!
           * @returns content
          */
          generate(): string;

          /**
           * Gets current value of property <code>charset</code>.Charset.
           * @returns Value of property <code>charset</code>
          */
          getCharset(): string;

          /**
           * Returns the number of columns.
           * @returns count
          */
          getColumnCount(): number;

          /**
           * Gets current value of property <code>fileExtension</code>.File extension.
           * @returns Value of property <code>fileExtension</code>
          */
          getFileExtension(): string;

          /**
           * Returns a metadata object for class sap.ui.core.util.ExportType.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Gets current value of property <code>mimeType</code>.MIME type.
           * @returns Value of property <code>mimeType</code>
          */
          getMimeType(): string;

          /**
           * Returns the number of rows.
           * @returns count
          */
          getRowCount(): number;

          /**
           * Creates a row "generator" (inspired by ES6 Generators)
           * @returns generator
          */
          rowGenerator(): any;

          /**
           * Sets a new value for property <code>charset</code>.Charset.When called with a value of
           * <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
           * @param sCharset New value for property <code>charset</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setCharset(sCharset: string): sap.ui.core.util.ExportType;

          /**
           * Sets a new value for property <code>fileExtension</code>.File extension.When called with a value of
           * <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
           * @param sFileExtension New value for property <code>fileExtension</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setFileExtension(sFileExtension: string): sap.ui.core.util.ExportType;

          /**
           * Sets a new value for property <code>mimeType</code>.MIME type.When called with a value of
           * <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
           * @param sMimeType New value for property <code>mimeType</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setMimeType(sMimeType: string): sap.ui.core.util.ExportType;
        }
        /**
         * Class to mock http requests made to a remote server
         * @resource sap/ui/core/util/MockServer.js
        */
        export abstract class MockServer extends sap.ui.base.ManagedObject {

          /**
           * Enum for the method.
          */
          public HTTPMETHOD: any;


          /**
           * Creates a mocked server. This helps to mock all or some backend calls, e.g. for OData/JSON Models or
           * simple XHR calls, withoutchanging the application code. This class can also be used for qunit
           * tests.Accepts an object literal <code>mSettings</code> that defines initialproperty values,
           * aggregated and associated objects as well as event handlers.See {@link
           * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
           * object.
           * @param sId id for the new server object; generated automatically if no non-empty id is given    
           * Note: this can be omitted, no matter whether <code>mSettings</code> will be given or not!
           * @param mSettings optional map/JSON-object with initial property values, aggregated objects etc. for
           * the new object
           * @param oScope scope object for resolving string based type and formatter references in bindings
          */
          constructor(sId: string, mSettings?: any, oScope?: any);



          /**
           * Attaches an event handler to be called after the built-in request processing of the mock server
           * @param event type according to HTTP Method
           * @param fnCallback the name of the function that will be called at this exitThe callback function
           * exposes an event with parameters, depending on the type of the request.oEvent.getParameters() lists
           * the parameters as per the request. Examples are:oXhr : the request object; oFilteredData : the mock
           * data entries that are about to be returned in the response; oEntry : the mock data entry that is
           * about to be returned in the response;
           * @param sEntitySet (optional) the name of the entity set
          */
          attachAfter(event: string, fnCallback: any, sEntitySet: string): void;

          /**
           * Attaches an event handler to be called before the built-in request processing of the mock server
           * @param event type according to HTTP Method
           * @param fnCallback the name of the function that will be called at this exit.The callback function
           * exposes an event with parameters, depending on the type of the request.oEvent.getParameters() lists
           * the parameters as per the request. Examples are:oXhr : the request object; sUrlParams : the URL
           * parameters of the request; sKeys : key properties of the requested entry; sNavProp/sNavName : name
           * of navigation
           * @param sEntitySet (optional) the name of the entity set
          */
          attachBefore(event: string, fnCallback: any, sEntitySet: string): void;

          /**
           * Cleans up the resources associated with this object and all its aggregated children.After an object
           * has been destroyed, it can no longer be used in!Applications should call this method if they don't
           * need the object any longer.
           * @param bSuppressInvalidate if true, this ManagedObject is not marked as changed
          */
          destroy(bSuppressInvalidate: boolean): void;

          /**
           * Removes a previously attached event handler
           * @param event type according to HTTP Method
           * @param fnCallback the name of the function that will be called at this exit
           * @param sEntitySet (optional) the name of the entity set
          */
          detachAfter(event: string, fnCallback: any, sEntitySet: string): void;

          /**
           * Removes a previously attached event handler
           * @param event type according to HTTP Method
           * @param fnCallback the name of the function that will be called at this exit
           * @param sEntitySet (optional) the name of the entity set
          */
          detachBefore(event: string, fnCallback: any, sEntitySet: string): void;


          /**
           * Returns the data model of the given EntitySet name.
           * @param sEntitySetName EntitySet name
           * @returns data model of the given EntitySet
          */
          getEntitySetData(sEntitySetName: any): any[];

          /**
           * Returns a metadata object for class sap.ui.core.util.MockServer.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Getter for property <code>requests</code>.Default value is <code>[]</code>
           * @returns the value of property <code>rootUri</code>
          */
          getRequests(): any[];

          /**
           * Getter for property <code>rootUri</code>.Default value is empty/<code>undefined</code>
           * @returns the value of property <code>rootUri</code>
          */
          getRootUri(): string;

          /**
           * Returns whether the server is started or not.
           * @returns whether the server is started or not.
          */
          isStarted(): boolean;

          /**
           * Sets the data of the given EntitySet name with the given array.
           * @param sEntitySetName EntitySet name
           * @param aData undefined
          */
          setEntitySetData(sEntitySetName: any, aData: any): void;

          /**
           * Setter for property <code>requests</code>.Default value is is <code>[]</code>Each array entry should
           * consist of an array with the following properties / values:<ul><li><b>method <string>:
           * "GET"|"POST"|"DELETE|"PUT"</b><br>(any HTTP verb)</li><li><b>path <string>:
           * "/path/to/resource"</b><br>The path is converted to a regular expression, so it can contain normal
           * regular expression syntax.All regular expression groups are forwarded as arguments to the
           * <code>response</code> function.In addition to this, parameters can be written in this notation:
           * <code>:param</code>. These placeholder will be replaced by regular expression
           * groups.</li><li><b>response <function>: function(xhr, param1, param2, ...) { }</b><br>The xhr object
           * can be used to respond on the request. Supported methods are:<br><code>xhr.respond(iStatusCode,
           * mHeaders, sBody)</code><br><code>xhr.respondJSON(iStatusCode, mHeaders, oJsonObjectOrString)</code>.
           * By default a JSON header is set for response header<br><code>xhr.respondXML(iStatusCode, mHeaders,
           * sXmlString)</code>. By default a XML header is set for response
           * header<br><code>xhr.respondFile(iStatusCode, mHeaders, sFileUrl)</code>. By default the mime type of
           * the file is set for response header</li></ul>
           * @param requests new value for property <code>requests</code>
          */
          setRequests(requests: any[]): void;

          /**
           * Setter for property <code>rootUri</code>. All request path URI are prefixed with this root URI if
           * set.Default value is empty/<code>undefined</code>
           * @param rootUri new value for property <code>rootUri</code>
          */
          setRootUri(rootUri: string): void;

          /**
           * Simulates an existing OData service by sepcifiying the metadata URL and the base URL for the
           * mockdata. The serverconfigures the request handlers depending on the service metadata. The mockdata
           * needs to be stored individually foreach entity type in a separate JSON file. The name of the JSON
           * file needs to match the name of the entity type. Ifno base url for the mockdata is specified then
           * the mockdata are generated from the metadata
           * @since 1.13.2
           * @param sMetadataUrl url to the service metadata document
           * @param vMockdataSettings (optional) base url which contains the path to the mockdata, or an object
           * which contains the following properties: sMockdataBaseUrl, bGenerateMissingMockData,
           * aEntitySetsNames. See below for descriptions of these parameters. Ommit this parameter to produce
           * random mock data based on the service metadata.
          */
          simulate(sMetadataUrl: string, vMockdataSettings?: string | any): void;

          /**
           * Starts the server.
          */
          start(): void;

          /**
           * Stops the server.
          */
          stop(): void;
        }
        /**
         * Can have a name and a cell template.
         * @resource sap/ui/core/util/ExportColumn.js
        */
        export class ExportColumn extends sap.ui.base.ManagedObject {


          /**
           * Constructor for a new ExportCell.Accepts an object literal <code>mSettings</code> that defines
           * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
           * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
           * object.
           * @param sId id for the new control, generated automatically if no id is given
           * @param mSettings initial settings for the new control
          */
          constructor(sId: string, mSettings?: any);



          /**
           * Destroys the template in the aggregation <code>template</code>.
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          destroyTemplate(): sap.ui.core.util.ExportColumn;


          /**
           * Returns a metadata object for class sap.ui.core.util.ExportColumn.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Gets current value of property <code>name</code>.Column name.
           * @returns Value of property <code>name</code>
          */
          getName(): string;

          /**
           * Gets content of aggregation <code>template</code>.Cell template for column.
          */
          getTemplate(): sap.ui.core.util.ExportCell;

          /**
           * Sets a new value for property <code>name</code>.Column name.When called with a value of
           * <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
           * @param sName New value for property <code>name</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setName(sName: string): sap.ui.core.util.ExportColumn;

          /**
           * Sets the aggregated <code>template</code>.
           * @param oTemplate The template to set
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setTemplate(oTemplate: sap.ui.core.util.ExportCell): sap.ui.core.util.ExportColumn;
        }
        /**
         * CSV export type. Can be used for {@link sap.ui.core.util.Export Export}.Please note that there could
         * be an issue with the separator char depending on the user's system language in some programs such as
         * Microsoft Excel.To prevent those issues use the data-import functionality which enables the
         * possibility to explicitly set the separator char that should be used.This way the content will be
         * displayed correctly.Potential formulas (cell data starts with one of = + - @) will be escaped by
         * prepending a single quote.As the export functionality is intended to be used with actual (user) data
         * there is no reason to allow formulas.
         * @resource sap/ui/core/util/ExportTypeCSV.js
        */
        export class ExportTypeCSV extends sap.ui.core.util.ExportType {


          /**
           * Constructor for a new ExportTypeCSV.Accepts an object literal <code>mSettings</code> that defines
           * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
           * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
           * object.
           * @param sId id for the new control, generated automatically if no id is given
           * @param mSettings initial settings for the new control
          */
          constructor(sId: string, mSettings?: any);




          /**
           * Generates the file content.
           * @returns content
          */
          generate(): string;

          /**
           * Returns a metadata object for class sap.ui.core.util.ExportTypeCSV.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Gets current value of property <code>separatorChar</code>.Separator char.Value needs to be exactly
           * one character or empty for default.Default value is <code>,</code>.
           * @returns Value of property <code>separatorChar</code>
          */
          getSeparatorChar(): string;

          /**
           * Setter for property <code>separatorChar</code>.Value needs to be exactly one character or empty for
           * default. Default value is ','.
           * @param sSeparatorChar new value for property <code>separatorChar</code>
           * @returns <code>this</code> to allow method chaining
          */
          setSeparatorChar(sSeparatorChar: string): sap.ui.core.util.ExportTypeCSV;
        }
      }
      namespace search {
        /**
         * Abstract base class for all SearchProviders which can be e.g. attached to a SearchField. Do not
         * create instances of this class, but use a concrete sub class instead.
         * @resource sap/ui/core/search/SearchProvider.js
        */
        export class SearchProvider extends sap.ui.core.Element {


          /**
           * Constructor for a new search/SearchProvider.Accepts an object literal <code>mSettings</code> that
           * defines initialproperty values, aggregated and associated objects as well as event handlers.See
           * {@link sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the
           * settings object.
           * @param sId id for the new control, generated automatically if no id is given
           * @param mSettings initial settings for the new control
          */
          constructor(sId: string, mSettings?: any);




          /**
           * Gets current value of property <code>icon</code>.Icon of the Search Provider
           * @returns Value of property <code>icon</code>
          */
          getIcon(): string;

          /**
           * Returns a metadata object for class sap.ui.core.search.SearchProvider.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Sets a new value for property <code>icon</code>.Icon of the Search ProviderWhen called with a value
           * of <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
           * @param sIcon New value for property <code>icon</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setIcon(sIcon: string): sap.ui.core.search.SearchProvider;

          /**
           * Call this function to get suggest values from the search provider.The given callback function is
           * called with the suggest value (type 'string', 1st parameter)and an array of the suggestions (type
           * '[string]', 2nd parameter).
           * @param sValue The value for which suggestions are requested.
           * @param fnCallback The callback function which is called when the suggestions are available.
          */
          suggest(sValue: string, fnCallback: any): void;
        }
        /**
         * A SearchProvider which uses the OpenSearch protocol (either JSON or XML).
         * @resource sap/ui/core/search/OpenSearchProvider.js
        */
        export class OpenSearchProvider extends sap.ui.core.search.SearchProvider {


          /**
           * Constructor for a new search/OpenSearchProvider.Accepts an object literal <code>mSettings</code>
           * that defines initialproperty values, aggregated and associated objects as well as event handlers.See
           * {@link sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the
           * settings object.
           * @param sId id for the new control, generated automatically if no id is given
           * @param mSettings initial settings for the new control
          */
          constructor(sId: string, mSettings?: any);




          /**
           * Returns a metadata object for class sap.ui.core.search.OpenSearchProvider.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Gets current value of property <code>suggestType</code>.The type of data which is provided by the
           * given suggestUrl: either 'json' or 'xml'.Default value is <code>json</code>.
           * @returns Value of property <code>suggestType</code>
          */
          getSuggestType(): string;

          /**
           * Gets current value of property <code>suggestUrl</code>.The URL for suggestions of the search
           * provider. As placeholder for the concrete search queries '{searchTerms}' must be used. For cross
           * domain requests maybe a proxy must be used.
           * @returns Value of property <code>suggestUrl</code>
          */
          getSuggestUrl(): any;

          /**
           * Sets a new value for property <code>suggestType</code>.The type of data which is provided by the
           * given suggestUrl: either 'json' or 'xml'.When called with a value of <code>null</code> or
           * <code>undefined</code>, the default value of the property will be restored.Default value is
           * <code>json</code>.
           * @param sSuggestType New value for property <code>suggestType</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setSuggestType(sSuggestType: string): sap.ui.core.search.OpenSearchProvider;

          /**
           * Sets a new value for property <code>suggestUrl</code>.The URL for suggestions of the search
           * provider. As placeholder for the concrete search queries '{searchTerms}' must be used. For cross
           * domain requests maybe a proxy must be used.When called with a value of <code>null</code> or
           * <code>undefined</code>, the default value of the property will be restored.
           * @param sSuggestUrl New value for property <code>suggestUrl</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setSuggestUrl(sSuggestUrl: any): sap.ui.core.search.OpenSearchProvider;

          /**
           * Call this function to get suggest values from the search provider.The given callback function is
           * called with the suggest value (type 'string', 1st parameter)and an array of the suggestions (type
           * '[string]', 2nd parameter).
           * @param sValue The value for which suggestions are requested.
           * @param fCallback The callback function which is called when the suggestions are available.
          */
          suggest(sValue: string, fCallback: any): void;
        }
      }
      namespace format {
        namespace NumberFormat {
          /**
           * Specifies a rounding behavior for numerical operations capable of discarding precision. Each
           * rounding mode in this object indicates how the leastsignificant returned digits of rounded result is
           * to be calculated.
          */
          enum RoundingMode {
            "AWAY_FROM_ZERO",
            "CEILING",
            "FLOOR",
            "HALF_AWAY_FROM_ZERO",
            "HALF_CEILING",
            "HALF_FLOOR",
            "HALF_TOWARDS_ZERO",
            "TOWARDS_ZERO"
          }
        }
        /**
         * The DateFormat is a static class for formatting and parsing date and time values accordingto a set
         * of format options.Supported format options are pattern based on Unicode LDML Date Format notation.If
         * no pattern is specified a default pattern according to the locale settings is used.
         * @resource sap/ui/core/format/DateFormat.js
        */
        export class DateFormat {


          /**
           * Constructor for DateFormat - must not be used: To get a DateFormat instance, please use getInstance,
           * getDateTimeInstance or getTimeInstance.
          */
          constructor();



          /**
           * Format a date according to the given format options.
           * @param oDate the value to format
           * @param bUTC whether to use UTC
           * @returns the formatted output value. If an invalid date is given, an empty string is returned.
          */
          format(oDate: Date, bUTC: boolean): string;

          /**
           * Get a date instance of the DateFormat, which can be used for formatting.
           * @param oFormatOptions Object which defines the format options
           * @param oLocale Locale to ask for locale specific texts/settings
           * @returns date instance of the DateFormat
          */
          getDateInstance(oFormatOptions: any, oLocale?: sap.ui.core.Locale): sap.ui.core.format.DateFormat;

          /**
           * Get a datetime instance of the DateFormat, which can be used for formatting.
           * @param oFormatOptions Object which defines the format options
           * @param oLocale Locale to ask for locale specific texts/settings
           * @returns datetime instance of the DateFormat
          */
          getDateTimeInstance(oFormatOptions: any, oLocale?: sap.ui.core.Locale): sap.ui.core.format.DateFormat;

          /**
           * Get a time instance of the DateFormat, which can be used for formatting.
           * @param oFormatOptions Object which defines the format options
           * @param oLocale Locale to ask for locale specific texts/settings
           * @returns time instance of the DateFormat
          */
          getTimeInstance(oFormatOptions: any, oLocale?: sap.ui.core.Locale): sap.ui.core.format.DateFormat;

          /**
           * Parse a string which is formatted according to the given format options.
           * @param sValue the string containing a formatted date/time value
           * @param bUTC whether to use UTC, if no timezone is contained
           * @param bStrict to use strict value check
           * @returns the parsed value
          */
          parse(sValue: string, bUTC: boolean, bStrict: boolean): Date;
        }
        /**
         * The NumberFormat is a static class for formatting and parsing numeric values accordingto a set of
         * format options.
         * @resource sap/ui/core/format/NumberFormat.js
        */
        export class NumberFormat extends sap.ui.base.Object {


          /**
           * Constructor for NumberFormat - must not be used: To get a NumberFormat instance, please use
           * getInstance, getFloatInstance or getIntegerInstance.
           * @param oFormatOptions The option object which support the following parameters. If no options is
           * given, default values according to the type and locale settings are used.
          */
          constructor(oFormatOptions: any);




          /**
           * Format a number according to the given format options.
           * @param oValue the number to format or an array which contains the number to format and the sMeasure
           * parameter
           * @param sMeasure a measure which has an impact on the formatting
           * @returns the formatted output value
          */
          format(oValue: number | any[], sMeasure?: string): string;

          /**
           * Get a currency instance of the NumberFormat, which can be used for formatting.If no locale is given,
           * the currently configured{@link sap.ui.core.Configuration.FormatSettings#getFormatLocale
           * formatLocale} will be used.<p>This instance has HALF_AWAY_FROM_ZERO set as default rounding
           * mode.Please set the roundingMode property in oFormatOptions to change thedefault value.</p>
           * @param oFormatOptions Object which defines the format options
           * @param oLocale Locale to get the formatter for
           * @returns integer instance of the NumberFormat
          */
          getCurrencyInstance(oFormatOptions: any, oLocale?: sap.ui.core.Locale): sap.ui.core.format.NumberFormat;

          /**
           * Get a float instance of the NumberFormat, which can be used for formatting.If no locale is given,
           * the currently configured{@link sap.ui.core.Configuration.FormatSettings#getFormatLocale
           * formatLocale} will be used.<p>This instance has HALF_AWAY_FROM_ZERO set as default rounding
           * mode.Please set the roundingMode property in oFormatOptions to change thedefault value.</p>
           * @param oFormatOptions Object which defines the format options
           * @param oLocale Locale to get the formatter for
           * @returns float instance of the NumberFormat
          */
          getFloatInstance(oFormatOptions: any, oLocale?: sap.ui.core.Locale): sap.ui.core.format.NumberFormat;

          /**
           * Get an integer instance of the NumberFormat, which can be used for formatting.If no locale is given,
           * the currently configured{@link sap.ui.core.Configuration.FormatSettings#getFormatLocale
           * formatLocale} will be used.<p>This instance has TOWARDS_ZERO set as default rounding mode.Please set
           * the roundingMode property in oFormatOptions to change thedefault value.</p>
           * @param oFormatOptions Object which defines the format options
           * @param oLocale Locale to get the formatter for
           * @returns integer instance of the NumberFormat
          */
          getIntegerInstance(oFormatOptions: any, oLocale?: sap.ui.core.Locale): sap.ui.core.format.NumberFormat;

          /**
           * Returns a metadata object for class sap.ui.core.format.NumberFormat.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Get a percent instance of the NumberFormat, which can be used for formatting.If no locale is given,
           * the currently configured{@link sap.ui.core.Configuration.FormatSettings#getFormatLocale
           * formatLocale} will be used.<p>This instance has HALF_AWAY_FROM_ZERO set as default rounding
           * mode.Please set the roundingMode property in oFormatOptions to change thedefault value.</p>
           * @param oFormatOptions Object which defines the format options
           * @param oLocale Locale to get the formatter for
           * @returns integer instance of the NumberFormat
          */
          getPercentInstance(oFormatOptions: any, oLocale?: sap.ui.core.Locale): sap.ui.core.format.NumberFormat;

          /**
           * Parse a string which is formatted according to the given format options.
           * @param sValue the string containing a formatted numeric value
           * @returns the parsed value or an array which contains the parsed value and the currency code (symbol)
           * when the NumberFormat is a currency instance
          */
          parse(sValue: string): number | any[];
        }
        /**
         * The FileSizeFormat is a static class for formatting and parsing numeric file size values accordingto
         * a set of format options.Supports the same options as {@link
         * sap.ui.core.format.NumberFormat.getFloatInstance NumberFormat.getFloatInstance}For format options
         * which are not specified default values according to the type and locale settings are used.Supported
         * format options (additional to NumberFormat):<ul><li>binaryFilesize: if true, base 2 is used: 1
         * Kibibyte = 1024 Byte, ... , otherwise base 10 is used: 1 Kilobyte = 1000 Byte (Default is
         * false)</li></ul>
         * @resource sap/ui/core/format/FileSizeFormat.js
        */
        export class FileSizeFormat extends sap.ui.base.Object {


          /**
           * Constructor for FileSizeFormat - must not be used: To get a FileSizeFormat instance, please use
           * getInstance.
          */
          constructor();




          /**
           * Format a filesize (in bytes) according to the given format options.
           * @param oValue the number (or hex string) to format
           * @returns the formatted output value
          */
          format(oValue: number | string): string;

          /**
           * Get an instance of the FileSizeFormat, which can be used for formatting.If no locale is given, the
           * currently configured{@link sap.ui.core.Configuration.FormatSettings#getFormatLocale formatLocale}
           * will be used.
           * @param oFormatOptions Object which defines the format options
           * @param oLocale Locale to get the formatter for
           * @returns instance of the FileSizeFormat
          */
          getInstance(oFormatOptions: any, oLocale?: sap.ui.core.Locale): sap.ui.core.format.FileSizeFormat;

          /**
           * Returns a metadata object for class sap.ui.core.format.FileSizeFormat.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Parse a string which is formatted according to the given format options.
           * @param sValue the string containing a formatted filesize value
           * @returns the parsed value in bytes
          */
          parse(sValue: string): number;
        }
      }
      namespace CSSSize {
        namespace hortHand {
        }
      }
      namespace service {
        /**
         * A service provides a specific functionality. A service instance can be obtainedby a {@link
         * sap.ui.core.service.ServiceFactory ServiceFactory} or at a Componentvia {@link
         * sap.ui.core.Component#getService getService} function.This class is the abstract base class for
         * services and needs to be extended:<pre>sap.ui.define("my/Service", [ 
         * "sap/ui/core/service/Service"], function(Service) {  return Service.extend("my.Service", {    init:
         * function() {      // handle init lifecycle    },    exit: function() {      // handle exit lifecycle
         *    },    doSomething: function() {      // some functionality    } });});</pre>A service instance
         * will have a service context:<pre>{  "scopeObject": oComponent, // the Component instance 
         * "scopeType": "component"   // the stereotype of the scopeObject}</pre>The service context can be
         * retrieved with the function <code>getContext</code>.This function is private to the service instance
         * and will not be exposed viathe service interface.For consumers of the service it is recommended to
         * provide the service instanceonly - as e.g. the {@link sap.ui.core.Component#getService getService}
         * functionof the Component does. The service interface can be accessed via
         * the<code>getInterface</code> function.Other private functions of the service instance are the
         * lifecycle functions.Currently there are two lifecycle functions: <code>init</code> and
         * <code>exit</code>.In addition the <code>destroy</code> function will also by hidden to avoidthe
         * control of the service lifecycle for service interface consumers.
         * @resource sap/ui/core/service/Service.js
        */
        export abstract class Service extends sap.ui.base.Object {





          /**
           * Lifecycle method to destroy the service instance.This function is not available on the service
           * interface.
          */
          destroy(bSuppressInvalidate: boolean): void;

          /**
           * Cleans up the service instance before destruction.Applications must not call this hook method
           * directly, it is called by theframework when the service is {@link #destroy destroyed}.Subclasses of
           * service should override this hook to implement any necessaryclean-up.
          */
          exit(): void;


          /**
           * Returns the context of the service:<pre>{  "scopeObject": oComponent, // the Component instance 
           * "scopeType": "component"   // the stereotype of the scopeObject}</pre>This function is not available
           * on the service interface.
           * @returns the context of the service
          */
          getContext(): any;

          /**
           * Returns the public interface of the service. By default, this filters theinternal functions like
           * <code>getInterface</code>, <code>getContext</code>and all other functions starting with "_".
           * Additionally the lifecyclefunctions <code>init</code>, <code>exit</code> and
           * <code>destroy</code>will be filtered for the service interface. This function can beoverridden in
           * order to self-create a service interface.This function is not available on the service interface.
           * @returns the public interface of the service
          */
          getInterface(): sap.ui.base.Interface;

          /**
           * Returns a metadata object for class sap.ui.core.service.Service.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Initializes the service instance after creation.Applications must not call this hook method
           * directly, it is called by theframework while the constructor of a service is executed.Subclasses of
           * service should override this hook to implement any necessaryinitialization.
          */
          init(): void;
        }
        /**
         * A service factory is used to create service instances for a specific context.The service factory
         * needs to be registered in a central{@link sap.ui.core.service.ServiceFactoryRegistry service factory
         * registry}.Consumers of services require the service factory to create service instances.The service
         * factory base class can be used in a generic way to act as afactory for any
         * service:<pre>sap.ui.require([  "sap/ui/core/service/ServiceFactoryRegistry", 
         * "sap/ui/core/service/ServiceFactory",  "my/Service"], function(ServiceFactoryRegistry,
         * ServiceFactory, MyService) {  ServiceFactoryRegistry.register(new
         * ServiceFactory(MService));});</pre>Additionally a concrete service factory can be implemented by
         * extending theservice factory base class if additional functionality is needed whencreating new
         * instances for a specific context:<pre>sap.ui.define("my/ServiceFactory", [ 
         * "sap/ui/core/service/ServiceFactoryRegistry",  "sap/ui/core/service/ServiceFactory",  "my/Service"],
         * function(ServiceFactoryRegistry, ServiceFactory, MyService) {  return
         * ServiceFactory.extend("my.ServiceFactory", {    createInstance: function(oServiceContext) {     
         * return Promise.resolve(new MyService(oServiceContext));    }  });});</pre>Another option for the
         * usage of the service factory is to provide astructured object with information about the service
         * which willcreate an anonymous service internally:<pre>sap.ui.define("my/ServiceFactory", [ 
         * "sap/ui/core/service/ServiceFactoryRegistry",  "sap/ui/core/service/ServiceFactory",  "my/Service"],
         * function(ServiceFactoryRegistry, ServiceFactory, MyService) {  return new ServiceFactory({    init:
         * function() { ... },    exit: function() { ... },    doSomething: function() { ... }  });});</pre>As
         * <code>createInstance</code> returns a <code>Promise</code> e.g. theservice module can also be loaded
         * asynchronously and resolve once themodule has been loaded and instantiated.
         * @resource sap/ui/core/service/ServiceFactory.js
        */
        export class ServiceFactory extends sap.ui.base.Object {





          /**
           * Creates a new instance of a service. When used as a generic service factoryby providing a service
           * constructor function it will create a new serviceinstance otherwise the function will fail. For
           * custom service factoriesthis function has to be overridden and should return a <code>Promise</code>.
           * @param oServiceContext Context for which the service is created
           * @returns Promise which resolves with the new Service instance.
          */
          createInstance(oServiceContext: any): JQueryPromise<any>;

          /**
           * Lifecycle method to destroy the service factory instance.
          */
          destroy(bSuppressInvalidate: boolean): void;


          /**
           * Returns a metadata object for class sap.ui.core.service.ServiceFactory.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;
        }
      }
      namespace message {
        /**
         * @resource sap/ui/core/message/Message.js
        */
        export class Message extends sap.ui.base.Object {


          /**
           * Constructor for a new Message.
           * @param mParameters (optional) a map which contains the following parameter properties:
          */
          constructor(mParameters: any);




          /**
           * Returns a metadata object for class sap.ui.core.message.Message.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;
        }
        /**
         * This is an abstract base class for MessageParser objects.
         * @resource sap/ui/core/message/MessageParser.js
        */
        export abstract class MessageParser extends sap.ui.base.Object {


          /**
           * Abstract MessageParser class to be inherited in back-end specific implementations.
          */
          constructor();




          /**
           * Returns a metadata object for class sap.ui.core.message.MessageParser.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Returns the registered processor on which the events for message handling can be fired
           * @returns The currently set MessageProcessor or null if none is set
          */
          getProcessor(): any;

          /**
           * Abstract parse method must be implemented in the inheriting class.
          */
          parse(oResponse?: any, oRequest?: any, mGetEntities?: any, mChangeEntities?: any): void;

          /**
           * This method is used by the model to register itself as MessageProcessor for this parser
           * @param oProcessor The MessageProcessor that can be used to fire events
           * @returns Instance reference for method chaining
          */
          setProcessor(oProcessor: any): any;
        }
        /**
         * @resource sap/ui/core/message/MessageManager.js
        */
        export class MessageManager extends sap.ui.base.EventProvider {


          /**
           * Constructor for a new MessageManager.
          */
          constructor();



          /**
           * Add messages to MessageManager
           * @param vMessages Array of sap.ui.core.message.Message or single sap.ui.core.message.Message
          */
          addMessages(vMessages: sap.ui.core.message.Message | sap.ui.core.message.Message[]): void;

          /**
           * destroy MessageManager
          */
          destroy(bSuppressInvalidate: boolean): void;


          /**
           * Get the MessageModel
           * @returns oMessageModel The Message Model
          */
          getMessageModel(): any;

          /**
           * Returns a metadata object for class sap.ui.core.message.MessageManager.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Register MessageProcessor
           * @param oProcessor The MessageProcessor
          */
          registerMessageProcessor(oProcessor: sap.ui.core.message.MessageProcessor): void;

          /**
           * Register ManagedObject: Validation and Parse errors are handled by the MessageManager for this
           * object
           * @param oObject The sap.ui.base.ManageObject
           * @param bHandleValidation Handle validation for this object. If set to true validation/parse events
           * creates Messages and cancel event.					If set to false only the event will be canceled, but no
           * messages will be created
          */
          registerObject(oObject: sap.ui.base.ManagedObject, bHandleValidation: boolean): void;

          /**
           * Remove all messages
          */
          removeAllMessages(): void;

          /**
           * Remove given Messages
           * @param vMessages The message(s) to be removed.
          */
          removeMessages(vMessages: sap.ui.core.message.Message | sap.ui.core.message.Message[]): void;

          /**
           * Deregister MessageProcessor
           * @param oProcessor The MessageProcessor
          */
          unregisterMessageProcessor(oProcessor: sap.ui.core.message.MessageProcessor): void;

          /**
           * Unregister ManagedObject
           * @param oObject The sap.ui.base.ManageObject
          */
          unregisterObject(oObject: sap.ui.base.ManagedObject): void;
        }
        /**
         * This is an abstract base class for MessageProcessor objects.
         * @resource sap/ui/core/message/MessageProcessor.js
        */
        export abstract class MessageProcessor extends sap.ui.base.EventProvider {


          /**
           * Constructor for a new MessageProcessor
          */
          constructor();



          /**
           * Attach event-handler <code>fnFunction</code> to the 'messageChange' event of this
           * <code>sap.ui.core.message.MessageProcessor</code>.<br/>
           * @param oData The object, that should be passed along with the event-object when firing the event.
           * @param fnFunction The function to call, when the event occurs. This function will be called on the  
           *         oListener-instance (if present) or in a 'static way'.
           * @param oListener Object on which to call the given function. If empty, this MessageProcessor is
           * used.
           * @returns <code>this</code> to allow method chaining
          */
          attachMessageChange(oData: any, fnFunction: any, oListener?: any): sap.ui.core.message.MessageProcessor;

          /**
           * Implement in inheriting classes
          */
          checkMessage(): sap.ui.model.ListBinding;

          /**
           * Destroys the MessageProcessor Instance
          */
          destroy(bSuppressInvalidate: boolean): void;

          /**
           * Detach event-handler <code>fnFunction</code> from the 'sap.ui.core.message.MessageProcessor' event
           * of this <code>sap.ui.core.message.MessageProcessor</code>.<br/>The passed function and listener
           * object must match the ones previously used for event registration.
           * @param fnFunction The function to call, when the event occurs.
           * @param oListener Object on which the given function had to be called.
           * @returns <code>this</code> to allow method chaining
          */
          detachMessageChange(fnFunction: any, oListener: any): sap.ui.core.message.MessageProcessor;


          /**
           * Fire event messageChange to attached listeners.
           * @param mArguments the arguments to pass along with the event.
           * @returns <code>this</code> to allow method chaining
          */
          fireMessageChange(mArguments: any): sap.ui.core.message.MessageProcessor;

          /**
           * Returns the ID of the MessageProcessor instance
           * @returns sId The MessageProcessor ID
          */
          getId(): string;

          /**
           * Returns a metadata object for class sap.ui.core.message.MessageProcessor.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Implement in inheriting classes
           * @param vMessages map of messages: {'target': [array of messages],...}
          */
          setMessages(vMessages: any): void;
        }
        /**
         * The ControlMessageProcessor implementation.This MessageProcessor is able to handle Messages with the
         * following target syntax:		'ControlID/PropertyName'Creating an instance of this class using the "new"
         * keyword always results in the same instance (Singleton).
         * @resource sap/ui/core/message/ControlMessageProcessor.js
        */
        export class ControlMessageProcessor extends sap.ui.core.message.MessageProcessor {


          /**
           * Constructor for a new ControlMessageProcessor
          */
          constructor();



          /**
           * Check Messages and update controls with messages
          */
          checkMessages(): void;


          /**
           * Returns a metadata object for class sap.ui.core.message.ControlMessageProcessor.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Set Messages to check
           * @param vMessages map of messages: {'target': [array of messages],...}
          */
          setMessages(vMessages: any): void;
        }
      }
      namespace routing {
        /**
         * @resource sap/ui/core/routing/Views.js
        */
        export class Views extends sap.ui.base.EventProvider {


          /**
           * Instantiates a view repository that creates and caches views. If it is destroyed, all the Views it
           * created are destroyed.Usually you do not have to create instances of this class, it is used by the
           * {@link sap.ui.core.routing.Router}.If you are using {@link sap.ui.core.routing.Targets} without
           * using a {@link sap.ui.core.UIComponent} you have to create an instance of this class.They will
           * create an instance on their own, or if they are used with a {@link sap.ui.core.UIComponent} they
           * will share the same instance of Views.
           * @param oOptions undefined
          */
          constructor(oOptions: any);



          /**
           * Attach event-handler <code>fnFunction</code> to the 'created' event of this
           * <code>sap.ui.core.routing.Views</code>.<br/>
           * @param oData The object, that should be passed along with the event-object when firing the event.
           * @param fnFunction The function to call, when the event occurs. This function will be called on
           * theoListener-instance (if present) or in a 'static way'.
           * @param oListener Object on which to call the given function.
           * @returns <code>this</code> to allow method chaining
          */
          attachCreated(oData: any, fnFunction: any, oListener?: any): sap.ui.core.routing.Views;

          /**
           * Detach event-handler <code>fnFunction</code> from the 'created' event of this
           * <code>sap.ui.core.routing.Views</code>.<br/>The passed function and listener object must match the
           * ones previously used for event registration.
           * @param fnFunction The function to call, when the event occurs.
           * @param oListener Object on which the given function had to be called.
           * @returns <code>this</code> to allow method chaining
          */
          detachCreated(fnFunction: any, oListener: any): sap.ui.core.routing.Views;


          /**
           * Fire event created to attached listeners.
           * @param mArguments the arguments to pass along with the event.
           * @returns <code>this</code> to allow method chaining
          */
          fireCreated(mArguments: any): sap.ui.core.routing.Views;

          /**
           * Returns a metadata object for class sap.ui.core.routing.Views.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;
        }
        /**
         * @resource sap/ui/core/routing/Route.js
        */
        export class Route extends sap.ui.base.EventProvider {


          /**
           * Instantiates a SAPUI5 Route
           * @param The router instance, the route will be added to.
           * @param oConfig configuration object for the route
           * @param oParent The parent route - if a parent route is given, the routeMatched event of this route
           * will also trigger the route matched of the parent and it will also create the view of the parent(if
           * provided).
          */
          constructor(The: sap.m.routing.Router, oConfig: any, oParent?: sap.ui.core.routing.Route);



          /**
           * Attach event-handler <code>fnFunction</code> to the 'matched' event of this
           * <code>sap.ui.core.routing.Route</code>.<br/>
           * @since 1.25.1
           * @param oData The object, that should be passed along with the event-object when firing the event.
           * @param fnFunction The function to call, when the event occurs. This function will be called on the  
           *         oListener-instance (if present) or in a 'static way'.
           * @param oListener Object on which to call the given function. If empty, this Model is used.
           * @returns <code>this</code> to allow method chaining
          */
          attachMatched(oData: any, fnFunction: any, oListener?: any): sap.ui.core.routing.Route;

          /**
           * Attach event-handler <code>fnFunction</code> to the 'patternMatched' event of this
           * <code>sap.ui.core.routing.Route</code>.<br/>
           * @since 1.25.1
           * @param oData The object, that should be passed along with the event-object when firing the event.
           * @param fnFunction The function to call, when the event occurs. This function will be called on the  
           *         oListener-instance (if present) or in a 'static way'.
           * @param oListener Object on which to call the given function. If empty, this Model is used.
           * @returns <code>this</code> to allow method chaining
          */
          attachPatternMatched(oData: any, fnFunction: any, oListener?: any): sap.ui.core.routing.Route;

          /**
           * Destroys a route
           * @returns this for chaining.
          */
          destroy(): sap.ui.core.routing.Route;

          /**
           * Detach event-handler <code>fnFunction</code> from the 'matched' event of this
           * <code>sap.ui.core.routing.Route</code>.<br/>The passed function and listener object must match the
           * ones previously used for event registration.
           * @since 1.25.1
           * @param fnFunction The function to call, when the event occurs.
           * @param oListener Object on which the given function had to be called.
           * @returns <code>this</code> to allow method chaining
          */
          detachMatched(fnFunction: any, oListener: any): sap.ui.core.routing.Route;

          /**
           * Detach event-handler <code>fnFunction</code> from the 'patternMatched' event of this
           * <code>sap.ui.core.routing.Route</code>.<br/>The passed function and listener object must match the
           * ones previously used for event registration.
           * @since 1.25.1
           * @param fnFunction The function to call, when the event occurs.
           * @param oListener Object on which the given function had to be called.
           * @returns <code>this</code> to allow method chaining
          */
          detachPatternMatched(fnFunction: any, oListener: any): sap.ui.core.routing.Route;


          /**
           * Returns a metadata object for class sap.ui.core.routing.Route.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Return the pattern of the route. If there are multiple patterns, the first pattern is returned
           * @returns the routes pattern
          */
          getPattern(): string;

          /**
           * Returns the URL for the route and replaces the placeholders with the values in oParameters
           * @param oParameters Parameters for the route
           * @returns the unencoded pattern with interpolated arguments
          */
          getURL(oParameters: any): string;
        }
        /**
         * @resource sap/ui/core/routing/Target.js
        */
        export class Target extends sap.ui.base.EventProvider {


          /**
           * Provides a convenient way for placing views into the correct containers of your application.<br/>The
           * main benefit of Targets is lazy loading: you do not have to create the views until you really need
           * them.<br/><b>Don't call this constructor directly</b>, use {@link sap.ui.core.routing.Targets}
           * instead, it will create instances of a Target.<br/>If you are using the mobile library, please use
           * the {@link sap.m.routing.Targets} constructor, please read the documentation there.<br/>
           * @param oOptions all of the parameters defined in {@link sap.m.routing.Targets#constructor} are
           * accepted here, except for children you need to specify the parent.
           * @param oViews All views required by this target will get created by the views instance using {@link
           * sap.ui.core.routing.Views#getView}
           * @param oParent the parent of this target. Will also get displayed, if you display this target. In
           * the config you have the fill the children property {@link sap.m.routing.Targets#constructor}
          */
          constructor(oOptions: any, oViews: sap.ui.core.routing.Views, oParent?: sap.ui.core.routing.Target);



          /**
           * Attach event-handler <code>fnFunction</code> to the 'display' event of this
           * <code>sap.ui.core.routing.Target</code>.<br/>
           * @param oData The object, that should be passed along with the event-object when firing the event.
           * @param fnFunction The function to call, when the event occurs. This function will be called on
           * theoListener-instance (if present) or in a 'static way'.
           * @param oListener Object on which to call the given function.
           * @returns <code>this</code> to allow method chaining
          */
          attachDisplay(oData: any, fnFunction: any, oListener?: any): sap.ui.core.routing.Target;

          /**
           * Destroys the target, will be called by {@link sap.m.routing.Targets} don't call this directly.
           * @returns this for chaining.
          */
          destroy(): sap.ui.core.routing.Target;

          /**
           * Detach event-handler <code>fnFunction</code> from the 'display' event of this
           * <code>sap.ui.core.routing.Target</code>.<br/>The passed function and listener object must match the
           * ones previously used for event registration.
           * @param fnFunction The function to call, when the event occurs.
           * @param oListener Object on which the given function had to be called.
           * @returns <code>this</code> to allow method chaining
          */
          detachDisplay(fnFunction: any, oListener: any): sap.ui.core.routing.Target;

          /**
           * Creates a view and puts it in an aggregation of a control that has been defined in the {@link
           * sap.ui.core.routing.Target#constructor}.
           * @param vData an object that will be passed to the display event in the data property. If the target
           * has parents, the data will also be passed to them.
           * @returns resolves with {name: *, view: *, control: *} if the target can be successfully displayed
           * otherwise it resolves with {name: *, error: *}
          */
          display(vData: any): JQueryPromise<any>;


          /**
           * Fire event created to attached listeners.
           * @param mArguments the arguments to pass along with the event.
           * @returns <code>this</code> to allow method chaining
          */
          fireDisplay(mArguments: any): sap.ui.core.routing.Target;

          /**
           * Returns a metadata object for class sap.ui.core.routing.Target.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;
        }
        /**
         * @resource sap/ui/core/routing/Router.js
        */
        export class Router extends sap.ui.base.EventProvider {


          /**
           * Instantiates a SAPUI5 Router
           * @param oRoutes may contain many Route configurations as {@link
           * sap.ui.core.routing.Route#constructor}.<br/>Each of the routes contained in the array/object will be
           * added to the router.<br/>One way of defining routes is an array:<pre>[    //Will create a route
           * called 'firstRouter' you can later use this name in navTo to navigate to this route    {       
           * name: "firstRoute"        pattern : "usefulPattern"    },    //Will create a route called
           * 'anotherRoute'    {        name: "anotherRoute"        pattern : "anotherPattern"    }]</pre>The
           * alternative way of defining routes is an Object.If you choose this way, the name attribute is the
           * name of the property.<pre>{    //Will create a route called 'firstRouter' you can later use this
           * name in navTo to navigate to this route    firstRoute : {        pattern : "usefulPattern"    },   
           * //Will create a route called 'anotherRoute'    anotherRoute : {        pattern : "anotherPattern"   
           * }}</pre>The values that may be provided are the same as in {@link
           * sap.ui.core.routing.Route#constructor}
           * @param oConfig Default values for route configuration - also takes the same parameters as {@link
           * sap.ui.core.routing.Target#constructor}.<br/>This config will be used for routes and for targets,
           * used in the router<br/>Eg: if the config object specifies :<pre><code>{    viewType :
           * "XML"}</code></pre>The targets look like this:<pre>{    xmlTarget : {        ...    },    jsTarget :
           * {        viewType : "JS"        ...    }}</pre>Then the effective config will look like this:<pre>{ 
           *   xmlTarget : {        viewType : "XML"        ...    },    jsTarget : {        viewType : "JS"     
           *   ...    }}</pre>Since the xmlTarget does not specify its viewType, XML is taken from the config
           * object. The jsTarget is specifying it, so the viewType will be JS.
           * @param oOwner the Component of all the views that will be created by this Router,<br/>will get
           * forwarded to the {@link sap.ui.core.routing.Views#contructor}.<br/>If you are using the
           * componentMetadata to define your routes you should skip this parameter.
           * @param oTargetsConfig available @since 1.28 the target configuration, see {@link
           * sap.ui.core.Targets#constructor} documentation (the options object).<br/>You should use Targets to
           * create and display views. Since 1.28 the route should only contain routing relevant
           * properties.<br/><b>Example:</b><pre><code>    new Router(    // Routes    [        {            //
           * no view creation related properties are in the route            name: "startRoute",            //no
           * hash            pattern: "",            // you can find this target in the targetConfig           
           * target: "welcome"        }    ],    // Default values shared by routes and Targets    {       
           * viewNamespace: "my.application.namespace",        viewType: "XML"    },    // You should only use
           * this constructor when you are not using a router with a component.    // Please use the metadata of
           * a component to define your routes and targets.    // The documentation can be found here: {@link
           * sap.ui.core.UIComponent#.extend}.    null,    // Target config    {         //same name as in the
           * route called 'startRoute'         welcome: {             // All properties for creating and placing
           * a view go here or in the config             viewName: "Welcome",             controlId: "app",      
           *       controlAggregation: "pages"         }    })</code></pre>
          */
          constructor(oRoutes: any | any[], oConfig?: any, oOwner?: sap.ui.core.UIComponent, oTargetsConfig?: any);



          /**
           * Adds a route to the router
           * @param oConfig configuration object for the route @see sap.ui.core.routing.Route#constructor
           * @param oParent The parent route - if a parent route is given, the routeMatched event of this route
           * will also trigger the route matched of the parent and it will also create the view of the parent (if
           * provided).
          */
          addRoute(oConfig: any, oParent: sap.ui.core.routing.Route): void;

          /**
           * Attach event-handler <code>fnFunction</code> to the 'bypassed' event of this
           * <code>sap.ui.core.routing.Router</code>.<br/>The event will get fired, if none of the routes of the
           * routes is matching. <br/>
           * @param oData The object, that should be passed along with the event-object when firing the event.
           * @param fnFunction The function to call, when the event occurs. This function will be called on the  
           *         oListener-instance (if present) or in a 'static way'.
           * @param oListener Object on which to call the given function. If empty, this Model is used.
           * @returns <code>this</code> to allow method chaining
          */
          attachBypassed(oData: any, fnFunction: any, oListener?: any): sap.m.routing.Router;

          /**
           * Attach event-handler <code>fnFunction</code> to the 'routeMatched' event of this
           * <code>sap.ui.core.routing.Router</code>.<br/>
           * @param oData The object, that should be passed along with the event-object when firing the event.
           * @param fnFunction The function to call, when the event occurs. This function will be called on the  
           *         oListener-instance (if present) or in a 'static way'.
           * @param oListener Object on which to call the given function. If empty, this Model is used.
           * @returns <code>this</code> to allow method chaining
          */
          attachRouteMatched(oData: any, fnFunction: any, oListener?: any): sap.m.routing.Router;

          /**
           * Attach event-handler <code>fnFunction</code> to the 'routePatternMatched' event of this
           * <code>sap.ui.core.routing.Router</code>.<br/>This event is similar to route matched. But it will
           * only fire for the route that has a matching pattern, not for its parent Routes <br/>
           * @param oData The object, that should be passed along with the event-object when firing the event.
           * @param fnFunction The function to call, when the event occurs. This function will be called on the  
           *         oListener-instance (if present) or in a 'static way'.
           * @param oListener Object on which to call the given function. If empty, this Model is used.
           * @returns <code>this</code> to allow method chaining
          */
          attachRoutePatternMatched(oData: any, fnFunction: any, oListener?: any): sap.m.routing.Router;

          /**
           * Attach event-handler <code>fnFunction</code> to the 'viewCreated' event of this
           * <code>sap.ui.core.routing.Router</code>.<br/>
           * @param oData The object, that should be passed along with the event-object when firing the event.
           * @param fnFunction The function to call, when the event occurs. This function will be called on
           * theoListener-instance (if present) or in a 'static way'.
           * @param oListener Object on which to call the given function. If empty, this Model is used.
           * @returns <code>this</code> to allow method chaining
          */
          attachViewCreated(oData: any, fnFunction: any, oListener?: any): sap.m.routing.Router;

          /**
           * Removes the router from the hash changer @see sap.ui.core.routing.HashChanger
           * @returns this for chaining.
          */
          destroy(): sap.m.routing.Router;

          /**
           * Detach event-handler <code>fnFunction</code> from the 'bypassed' event of this
           * <code>sap.ui.core.routing.Router</code>.<br/>The event will get fired, if none of the routes of the
           * routes is matching. <br/>The passed function and listener object must match the ones previously used
           * for event registration.
           * @param fnFunction The function to call, when the event occurs.
           * @param oListener Object on which the given function had to be called.
           * @returns <code>this</code> to allow method chaining
          */
          detachBypassed(fnFunction: any, oListener: any): sap.m.routing.Router;

          /**
           * Detach event-handler <code>fnFunction</code> from the 'routeMatched' event of this
           * <code>sap.ui.core.routing.Router</code>.<br/>The passed function and listener object must match the
           * ones previously used for event registration.
           * @param fnFunction The function to call, when the event occurs.
           * @param oListener Object on which the given function had to be called.
           * @returns <code>this</code> to allow method chaining
          */
          detachRouteMatched(fnFunction: any, oListener: any): sap.m.routing.Router;

          /**
           * Detach event-handler <code>fnFunction</code> from the 'routePatternMatched' event of this
           * <code>sap.ui.core.routing.Router</code>.<br/>This event is similar to route matched. But it will
           * only fire for the route that has a matching pattern, not for its parent Routes <br/>The passed
           * function and listener object must match the ones previously used for event registration.
           * @param fnFunction The function to call, when the event occurs.
           * @param oListener Object on which the given function had to be called.
           * @returns <code>this</code> to allow method chaining
          */
          detachRoutePatternMatched(fnFunction: any, oListener: any): sap.m.routing.Router;

          /**
           * Detach event-handler <code>fnFunction</code> from the 'viewCreated' event of this
           * <code>sap.ui.core.routing.Router</code>.<br/>The passed function and listener object must match the
           * ones previously used for event registration.
           * @param fnFunction The function to call, when the event occurs.
           * @param oListener Object on which the given function had to be called.
           * @returns <code>this</code> to allow method chaining
          */
          detachViewCreated(fnFunction: any, oListener: any): sap.m.routing.Router;


          /**
           * Fire event bypassed to attached listeners.The event will get fired, if none of the routes of the
           * routes is matching. <br/>
           * @param mArguments the arguments to pass along with the event.
           * @returns <code>this</code> to allow method chaining
          */
          fireBypassed(mArguments: any): sap.m.routing.Router;

          /**
           * Fire event routeMatched to attached listeners.
           * @param mArguments the arguments to pass along with the event.
           * @returns <code>this</code> to allow method chaining
          */
          fireRouteMatched(mArguments: any): sap.m.routing.Router;

          /**
           * Fire event routePatternMatched to attached listeners.This event is similar to route matched. But it
           * will only fire for the route that has a matching pattern, not for its parent Routes <br/>
           * @param mArguments the arguments to pass along with the event.
           * @returns <code>this</code> to allow method chaining
          */
          fireRoutePatternMatched(mArguments: any): sap.m.routing.Router;

          /**
           * Fire event viewCreated to attached listeners.
           * @param mArguments the arguments to pass along with the event.
           * @returns <code>this</code> to allow method chaining
          */
          fireViewCreated(mArguments: any): sap.m.routing.Router;

          /**
           * Returns a metadata object for class sap.ui.core.routing.Router.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Returns the Route with a name, if no route is found undefined is returned
           * @since 1.25.1
           * @param sName Name of the route
           * @returns the route with the provided name or undefined.
          */
          getRoute(sName: string): sap.ui.core.routing.Route;

          /**
           * Get a registered router
           * @param sName Name of the router
           * @returns The router with the specified name, else undefined
          */
          getRouter(sName: string): sap.m.routing.Router;

          /**
           * Returns the instance of Targets, if you pass a targets config to the router
           * @returns The instance of targets, the router uses to place views or undefined if you did not specify
           * the targets parameter in the router's constructor.
          */
          getTargets(): sap.ui.core.routing.Targets | any;

          /**
           * Returns the URL for the route and replaces the placeholders with the values in oParameters
           * @param sName Name of the route
           * @param oParameters Parameters for the route
           * @returns the unencoded pattern with interpolated arguments
          */
          getURL(sName: string, oParameters?: any): string;

          /**
           * Returns a cached view for a given name or creates it if it does not yet exists
           * @param sViewName Name of the view
           * @param sViewType Type of the view
           * @param sViewId Optional view id
           * @returns the view instance
          */
          getView(sViewName: string, sViewType: string, sViewId: string): sap.ui.core.mvc.View;

          /**
           * Returns the views instance created by the router
           * @since 1.28
           * @returns the Views instance
          */
          getViews(): sap.ui.core.routing.Views;

          /**
           * Attaches the router to the hash changer @see sap.ui.core.routing.HashChanger
           * @returns this for chaining.
          */
          initialize(): sap.m.routing.Router;

          /**
           * Navigates to a specific route defining a set of parameters. The Parameters will be URI encoded - the
           * characters ; , / ? : @ & = + $ are reserved and will not be encoded.If you want to use special
           * characters in your oParameters, you have to encode them (encodeURIComponent).IF the given route name
           * can't be found, an error message is logged to the console and the hash will be changed to empty
           * string.
           * @param sName Name of the route
           * @param oParameters Parameters for the route
           * @param bReplace Defines if the hash should be replaced (no browser history entry) or set (browser
           * history entry)
           * @returns this for chaining.
          */
          navTo(sName: string, oParameters?: any, bReplace?: boolean): sap.m.routing.Router;

          /**
           * Will trigger routing events + place targets for routes matching the string
           * @param sNewHash a new hash
          */
          parse(sNewHash: string): void;

          /**
           * Registers the router to access it from another context. Use sap.ui.routing.Router.getRouter() to
           * receive the instance
           * @param sName Name of the router
          */
          register(sName: string): void;

          /**
           * Adds or overwrites a view in the viewcache of the router, the viewname serves as a key
           * @since 1.22
           * @param sViewName Name of the view
           * @param oView the view instance
           * @returns @since 1.28 the this pointer for chaining
          */
          setView(sViewName: string, oView: sap.ui.core.mvc.View): sap.m.routing.Router;

          /**
           * Stops to listen to the hashChange of the browser.</br>If you want the router to start again, call
           * initialize again.
           * @returns this for chaining.
          */
          stop(): sap.m.routing.Router;
        }
        /**
         * @resource sap/ui/core/routing/History.js
        */
        export class History {


          /**
           * Used to determine the {@link sap.ui.core.HistoryDirection} of the current or a future
           * navigation,done with a {@link sap.ui.core.routing.Router} or {@link
           * sap.ui.core.routing.HashChanger}.<strong>ATTENTION:</strong> this class will not be accurate if
           * someone does hash-replacement without the named classes aboveIf you are manipulating the hash
           * directly this class is not supported anymore.
           * @param oHashChanger required, without a HashChanger this class cannot work. The class needs to be
           * aware of the hash-changes.
          */
          constructor(oHashChanger: sap.ui.core.routing.HashChanger);



          /**
           * Determines what the navigation direction for a newly given hash would beIt will say Unknown if there
           * is a history foo - bar (current history) - fooIf you now ask for the direction of the hash "foo" you
           * get Unknown because it might be backwards or forwards.For hash replacements, the history stack will
           * be replaced at this position for the history.
           * @param sNewHash optional, if this parameter is not passed the last hashChange is taken.
           * @returns or undefined, if no navigation has taken place yet.
          */
          getDirection(sNewHash: string): any;

          /**
           * @returns a global singleton that gets created as soon as the sap.ui.core.routing.History is required
          */
          getInstance(): sap.ui.core.routing.History;

          /**
           * gets the previous hash in the history - if the last direction was Unknown or there was no navigation
           * yet, undefined will be returned
           * @returns or undefined
          */
          getPreviousHash(): string;
        }
        /**
         * @resource sap/ui/core/routing/Targets.js
        */
        export class Targets extends sap.ui.base.EventProvider {


          /**
           * Provides a convenient way for placing views into the correct containers of your application.The main
           * benefit of Targets is lazy loading: you do not have to create the views until you really need
           * them.If you are using the mobile library, please use {@link sap.m.routing.Targets} instead of this
           * class.
           * @param oOptions undefined
          */
          constructor(oOptions: any);



          /**
           * Creates a target by using the given name and options. If there's already a target with the same name
           * exists, the existing target is kept from being overwritten and an error log will be written to the
           * development console.
           * @param sName the name of a target
           * @param oTarget the options of a target. The option names are the same as the ones in
           * "oOptions.targets.anyName" of {@link constructor}.
           * @returns Targets itself for method chaining
          */
          addTarget(sName: string, oTarget: any): sap.ui.core.routing.Targets;

          /**
           * Attach event-handler <code>fnFunction</code> to the 'display' event of this
           * <code>sap.ui.core.routing.Targets</code>.<br/>
           * @param oData The object, that should be passed along with the event-object when firing the event.
           * @param fnFunction The function to call, when the event occurs. This function will be called on
           * theoListener-instance (if present) or in a 'static way'.
           * @param oListener Object on which to call the given function.
           * @returns <code>this</code> to allow method chaining
          */
          attachDisplay(oData: any, fnFunction: any, oListener?: any): sap.ui.core.routing.Targets;

          /**
           * Destroys the targets instance and all created targets. Does not destroy the views instance passed to
           * the constructor. It has to be destroyed separately.
           * @returns this for chaining.
          */
          destroy(): sap.ui.core.routing.Targets;

          /**
           * Detach event-handler <code>fnFunction</code> from the 'display' event of this
           * <code>sap.ui.core.routing.Targets</code>.<br/>The passed function and listener object must match the
           * ones previously used for event registration.
           * @param fnFunction The function to call, when the event occurs.
           * @param oListener Object on which the given function had to be called.
           * @returns <code>this</code> to allow method chaining
          */
          detachDisplay(fnFunction: any, oListener: any): sap.ui.core.routing.Targets;

          /**
           * Creates a view and puts it in an aggregation of the specified control.
           * @param vTargets the key of the target as specified in the {@link #constructor}. To display multiple
           * targets you may also pass an array of keys.
           * @param vData an object that will be passed to the display event in the data property. If the target
           * has parents, the data will also be passed to them.
           * @returns this pointer for chaining
          */
          display(vTargets: string | string[], vData?: any): sap.ui.core.routing.Targets;


          /**
           * Fire event created to attached listeners.
           * @param mArguments the arguments to pass along with the event.
           * @returns <code>this</code> to allow method chaining
          */
          fireDisplay(mArguments: any): sap.ui.core.routing.Targets;

          /**
           * Returns a metadata object for class sap.ui.core.routing.Targets.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Returns a target by its name (if you pass myTarget: { view: "myView" }) in the config myTarget is
           * the name.
           * @param vName the name of a single target or the name of multiple targets
           * @returns The target with the coresponding name or undefined. If an array way passed as name this
           * will return an array with all found targets. Non existing targets will not be returned but will log
           * an error.
          */
          getTarget(vName: string | string[]): sap.ui.core.routing.Target | any | sap.ui.core.routing.Target[];

          /**
           * Returns the views instance passed to the constructor
           * @returns the views instance
          */
          getViews(): sap.ui.core.routing.Views;
        }
        /**
         * Class for manipulating and receiving changes of the browserhash with the hasher framework.Fires a
         * "hashChanged" event if the browser hash changes.
         * @resource sap/ui/core/routing/HashChanger.js
        */
        export class HashChanger extends sap.ui.base.EventProvider {


          constructor();



          /**
           * Cleans the event registration
          */
          destroy(bSuppressInvalidate: boolean): void;


          /**
           * Fires the hashchanged event, may be extended to modify the hash before fireing the event
           * @param newHash the new hash of the browser
           * @param oldHash the previous hash
          */
          fireHashChanged(newHash: string, oldHash: string): void;

          /**
           * Gets the current hash
           * @returns the current hash
          */
          getHash(): string;

          /**
           * Gets a global singleton of the HashChanger. The singleton will get created when this function is
           * invoked for the first time.
          */
          getInstance(): void;

          /**
           * Returns a metadata object for class sap.ui.core.routing.HashChanger.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Will start listening to hashChanges with the parseHash function.This will also fire a hashchanged
           * event with the initial hash.
          */
          init(): void;

          /**
           * Replaces the hash to a certain value. When using the replace function no browser history is
           * written.If you want to have an entry in the browser history, please use set setHash function.
           * @param sHash the hash
          */
          replaceHash(sHash: string): void;

          /**
           * Sets the hashChanger to a new instance, destroys the old one and copies all its event listeners to
           * the new one
           * @param oHashChanger the new instance for the global singleton
          */
          replaceHashChanger(oHashChanger: sap.ui.core.routing.HashChanger): void;

          /**
           * Sets the hash to a certain value. When using the set function a browser history  entry is written.If
           * you do not want to have an entry in the browser history, please use set replaceHash function.
           * @param sHash the hash
          */
          setHash(sHash: string): void;
        }
        /**
         * Enumaration for different HistoryDirections
        */
        namespace routing {

          enum HistoryDirection {
            Backwards,
            Forwards,
            NewEntry,
            Unknown
          }
        }
      }
      namespace theming {
        namespace Parameters {

          /**
           * Returns the scopes from current theming parameters.
           * @param bAvoidLoading Whether loading of parameters should be avoided
           * @returns Scope names
          */
          function _getScopes(bAvoidLoading: boolean): any[];

          /**
           * Returns the current value for one or more theming parameters, depending on the given
           * arguments.<ul><li>If no parameter is given a key-value map containing all parameters is
           * returned</li><li>If a <code>string</code> is given as first parameter the value is returned as a
           * <code>string</code></li><li>If an <code>array</code> is given as first parameter a key-value map
           * containing all parameters from the <code>array</code> is returned</li></ul><p>The returned key-value
           * maps are a copy so changing values in the map does not have any effect</p>
           * @param vName the (array with) CSS parameter name(s)
           * @param oElement Element / control instance to take into account when looking for a parameter value. 
           *                         This can make a difference when a parameter value is overridden in a theme
           * scope set via a CSS class.
           * @returns the CSS parameter value(s)
          */
          function get(vName: string | string[], oElement?: sap.ui.core.Element): string | any | any;

          /**
           * Returns the active scope(s) for a given control by looking up the hierarchy.The lookup navigates the
           * DOM hierarchy if it's available. Otherwise if controls aren't rendered yet,it navigates the control
           * hierarchy. By navigating the control hierarchy, inner-html elementswith the respective scope classes
           * can't get recognized as the Custom Style Class API does only forroot elements.
           * @param oElement element/control instance
           * @returns Two dimensional array with scopes in bottom up order
          */
          function getActiveScopesFor(oElement: any): string[][];

          /**
           * Resets the CSS parameters which finally will reload the parametersthe next time they are queried via
           * the method <code>get</code>.
          */
          function reset(): void;
        }
      }
      namespace CSSColor {
      }
      namespace delegate {
        /**
         * Delegate for the navigation between DOM nodes with the keyboard.The <code>ItemNavigation</code>
         * provides keyboard and mouse navigation between DOM nodes representing items.This means that controls
         * rendering a list of items can attach this delegate to get a common keyboard and mouse supportto
         * navigate between these items.It is possible to navigate between the items via the arrow keys.If
         * needed, paging using the Page Up and Page Down keys is possible. (To activate call
         * <code>setPageSize</code> with a value &gt; 0.)HOME and END keys are also supported.Focusing an item
         * via mouse also is also supported. For mouse navigation, the <code>mousedown</code> event is used.As
         * the <code>ItemNavigation</code> works with DOM nodes, the items and the control area must be
         * provided asDOM references. There is one root DOM reference (set via <code>setRootDomRef</code>).All
         * item DOM references (set via <code>setItemDomRefs</code>) must be places somewhere inside of this
         * root DOM reference.Only focusable items are used for the navigation, meaning disabled items or
         * separator items are just ignored by navigatingthrough the items. In some cases however, it makes
         * sense to put the non-focusable items in the array of the DOM references tokeep the indexes stable or
         * like in the calling control.<b>Hint:</b> To make a DOM reference focusable a <code>tabindex</code>
         * of -1 can be set.<b>Note</b> After re-rendering of the control or changing the DOM nodes of the
         * control, theDOM references of the <code>ItemNavigation</code> must be updated. Then the same
         * item(corresponding to the index) will get the focus.The <code>ItemNavigation</code> adjusts the
         * <code>tabindex</code> of all DOM references relating to the currentfocused item. So if the control
         * containing the items gets the focus (e.g. via tab navigation),it is always the focused items which
         * will be focused.<b>Note:</b> If the <code>ItemNavigation</code> is nested in another
         * <code>ItemNavigation</code>(e.g. <code>SegmentedButton</code> in <code>Toolbar</code>), the
         * <code>RootDomRef</code> will always have <code>tabindex</code> -1.Per default the
         * <code>ItemNavigation</code> cycles over the items.It navigates again to the first item if the Arrow
         * Down or Arrow Right key is pressed whilethe last item has the focus. It navigates to the last item
         * if arrow up orarrow left is pressed while the first item has the focus.If you want to stop the
         * navigation at the first and last item,call the <code>setCycling</code> method with a value of
         * <code>false</code>.It is possible to have multiple columns in the item navigation. If multiple
         * columnsare used, the keyboard navigation changes. The Arrow Right and Arrow Left keys will take the
         * user to the next or previousitem, and the Arrow Up and Arrow Down keys will navigate the same way
         * but in a vertical direction.The <code>ItemNavigation</code> also allows setting a selected index
         * that is used to identifythe selected item. Initially, if no other focus is set, the selected item
         * will be the focused one.Note that navigating through the items will not change the selected item,
         * only the focus.(For example a radio group has one selected item.)
         * @resource sap/ui/core/delegate/ItemNavigation.js
        */
        export class ItemNavigation extends sap.ui.base.EventProvider {


          /**
           * Creates an <code>ItemNavigation</code> delegate that can be attached to controls
           * requiringcapabilities for keyboard navigation between items.
           * @param oDomRef The root DOM reference that includes all items
           * @param aItemDomRefs Array of DOM references representing the items for the navigation
           * @param bNotInTabChain Whether the selected element should be in the tab chain or not
          */
          constructor(oDomRef: sap.ui.core.Element, aItemDomRefs: Element[], bNotInTabChain?: boolean);




          /**
           * Returns disabled modifiersThese modifiers will not be handled by the <code>ItemNavigation</code>
           * @param oDisabledModifiers Object that includes event type with disabled keys as an array
           * @returns Object that includes event type with disabled keys as an array
          */
          getDisabledModifiers(oDisabledModifiers: any): any;

          /**
           * Returns the array of item DOM references
           * @returns Array of item DOM references
          */
          getItemDomRefs(): Element[];

          /**
           * Returns a metadata object for class sap.ui.core.delegate.ItemNavigation.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Returns the root DOM reference surrounding the items
           * @returns Root DOM reference
          */
          getRootDomRef(): sap.ui.core.Element;

          /**
           * Check whether given event has disabled modifier or not
           * @param oEvent jQuery event
           * @returns Flag if disabled modifiers are set
          */
          hasDisabledModifier(oEvent: any): Boolean;

          /**
           * Sets whether the items are displayed in columns.If columns are used, the Arrow Up and Arrow Down
           * keys navigate to the next or previousitem of the column. If the first or last item of the column is
           * reached, the next focuseditem is then in the next or previous column.
           * @param iColumns Count of columns for the table mode or cycling mode
           * @param bNoColumnChange Forbids jumping to an other column with Arrow Up and Arrow Down keys
           * @returns <code>this</code> to allow method chaining
          */
          setColumns(iColumns: number, bNoColumnChange: boolean): sap.ui.core.delegate.ItemNavigation;

          /**
           * Sets whether the <code>ItemNavigation</code> should cycle through the items.If cycling is disabled
           * the navigation stops at the first and last item, if the corresponding arrow keys are used.
           * @param bCycling Set to true if cycling should be done, else false
           * @returns <code>this</code> to allow method chaining
          */
          setCycling(bCycling: boolean): sap.ui.core.delegate.ItemNavigation;

          /**
           * Sets the disabled modifiersThese modifiers will not be handled by the
           * <code>ItemNavigation</code><pre>Example: Disable shift + up handling of the
           * <code>ItemNavigation</code>oItemNavigation.setDisabledModifiers({    sapnext : ["shift"]});Possible
           * keys are : "shift", "alt", "ctrl", "meta"Possible events are : "sapnext", "sapprevious", "saphome",
           * "sapend"</pre>
           * @param oDisabledModifiers Object that includes event type with disabled keys as an array
           * @returns <code>this</code> to allow method chaining
          */
          setDisabledModifiers(oDisabledModifiers: any): sap.ui.core.delegate.ItemNavigation;

          /**
           * Sets behavior of HOME and END keys if columns are used.
           * @param bStayInRow HOME -> go to first item in row; END -> go to last item in row
           * @param bCtrlEnabled HOME/END with CTRL -> go to first/last item of all
           * @returns <code>this</code> to allow method chaining
          */
          setHomeEndColumnMode(bStayInRow: boolean, bCtrlEnabled: boolean): sap.ui.core.delegate.ItemNavigation;

          /**
           * Sets the item DOM references as an array for the items
           * @param aItemDomRefs Array of DOM references representing the items
           * @returns <code>this</code> to allow method chaining
          */
          setItemDomRefs(aItemDomRefs: Element[]): sap.ui.core.delegate.ItemNavigation;

          /**
           * Sets the page size of the item navigation to allow Page Up and Page Down keys.
           * @param iPageSize The page size, needs to be at least 1
           * @returns <code>this</code> to allow method chaining
          */
          setPageSize(iPageSize: number): sap.ui.core.delegate.ItemNavigation;

          /**
           * Sets the root DOM reference surrounding the items
           * @param oDomRef Root DOM reference
           * @returns <code>this</code> to allow method chaining
          */
          setRootDomRef(oDomRef: any): sap.ui.core.delegate.ItemNavigation;

          /**
           * Sets the selected index if the used control supports selection.
           * @param iIndex Index of the first selected item
           * @returns <code>this</code> to allow method chaining
          */
          setSelectedIndex(iIndex: number): sap.ui.core.delegate.ItemNavigation;

          /**
           * Sets whether the <code>ItemNavigation</code> should use the table mode to navigate throughthe items
           * (navigation in a grid).
           * @param bTableMode Set to true if table mode should be used, else false
           * @param bTableList This sets a different behavior for table mode.In this mode we keep using table
           * navigation but there are some differences. e.g.<ul>	<li>Page-up moves focus to the first row, not to
           * the first cell like in table mode</li>	<li>Page-down moves focus to the last row, not to the last
           * cell like in table mode</li></ul>
           * @returns <code>this</code> to allow method chaining
          */
          setTableMode(bTableMode: boolean, bTableList?: boolean): sap.ui.core.delegate.ItemNavigation;
        }
        /**
         * Delegate for touch scrolling on mobile devicesThis delegate uses CSS (-webkit-overflow-scrolling)
         * only if supported. Otherwise the desiredscrolling library is used. Please also consider the
         * documentationof the library for a proper usage.Controls that implement ScrollEnablement should
         * additionally provide the getScrollDelegate method that returnsthe current instance of this delegate
         * object
         * @resource sap/ui/core/delegate/ScrollEnablement.js
        */
        export class ScrollEnablement extends sap.ui.base.Object {





          /**
           * Destroys this Scrolling delegate.This function must be called by the control which uses this
           * delegate in the <code>exit</code> function.
          */
          destroy(bSuppressInvalidate: boolean): void;


          /**
           * Calculates scroll position of a child of a container.
           * @param vElement An element(DOM or jQuery) for which the scroll position will be calculated.
           * @returns Position object.
          */
          getChildPosition(vElement: HTMLElement | typeof jQuery): any;

          /**
           * Get current setting for horizontal scrolling.
           * @since 1.9.1
           * @returns true if horizontal scrolling is enabled
          */
          getHorizontal(): boolean;

          /**
           * Returns a metadata object for class sap.ui.core.delegate.ScrollEnablement.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Get current setting for vertical scrolling.
           * @since 1.9.1
           * @returns true if vertical scrolling is enabled
          */
          getVertical(): boolean;

          /**
           * Refreshes this Scrolling delegate.
          */
          refresh(): void;

          /**
           * Scrolls to an element within a container.
           * @param oElement A DOM element.
           * @param iTime The duration of animated scrolling in milliseconds. To scroll immediately without
           * animation, give 0 as value.
          */
          scrollToElement(oElement: HTMLElement, iTime?: number): ScrollEnablement;

          /**
           * Setter for property <code>bounce</code>.
           * @since 1.17
           * @param bBounce new value for property <code>bounce</code>.
          */
          setBounce(bBounce: boolean): void;

          /**
           * Sets GrowingList control to scroll container
           * @since 1.11.0
           * @param fnScrollLoadCallback Scrolling callback
           * @param sScrollLoadDirection Scrolling directionThis function is supported in iScroll and mouse
           * delegates only.
          */
          setGrowingList(fnScrollLoadCallback: any, sScrollLoadDirection: sap.m.ListGrowingDirection): void;

          /**
           * Enable or disable horizontal scrolling.
           * @param bHorizontal set true to enable horizontal scrolling, false - to disable
          */
          setHorizontal(bHorizontal: boolean): void;

          /**
           * Sets IconTabBar control to scroll container
           * @since 1.16.1
           * @param IconTabBar instanceThis function is supported in iScroll only.
          */
          setIconTabBar(IconTabBar: sap.m.IconTabBar): void;

          /**
           * Set overflow control on top of scroll container.
           * @since 1.9.2
           * @param top control that should be normally hidden overthe top border of the scroll container
           * (pull-down content).This function is supported in iScroll delegates only. In MouseScroll delegates
           * the element is not hidden and should have an appropriate rendering for being always displayed and
           * should have an alternative way for triggering (e.g. a Button).
          */
          setPullDown(top: sap.ui.core.Control): void;

          /**
           * Enable or disable vertical scrolling.
           * @param bVertical set true to enable vertical scrolling, false - to disable
          */
          setVertical(bVertical: boolean): void;
        }
      }
      namespace Renderer {


        /**
         * Returns the TextAlignment for the provided configuration.
         * @param oTextAlign the text alignment of the Control
         * @param oTextDirection the text direction of the Control
         * @returns the actual text alignment that must be set for this environment
        */
        function getTextAlign(oTextAlign: sap.ui.core.TextAlign, oTextDirection: sap.ui.core.TextDirection): string;
      }
      namespace IconPool {

        /**
         * Register an additional icon to the sap.ui.core.IconPool.
         * @param iconName the name of the icon.
         * @param collectionName the name of icon collection. The built in icons are with empty collectionName,
         * so if additional icons need to be registered in IconPool, the collectionName can't be empty.
         * @param iconInfo the icon info which contains the following properties:
         * @returns the info object of the registered icon which has the name, collection, uri, fontFamily,
         * content and suppressMirroring properties.
        */
        function addIcon(iconName: string, collectionName: string, iconInfo: any): any;

        /**
         * Creates an instance of {@link sap.ui.core.Icon} if the given URI is an icon URI, otherwise the given
         * constructor is called.The given URI is set to the src property of the control.
         * @param setting contains the properties which will be used to instantiate the returned control. It
         * should contain at least a property named src. If it's given with a string type, it will be taken as
         * the value of src property.
         * @param constructor the constructor function which is called when the given URI isn't an icon URI
         * @returns either an instance of sap.ui.core.Icon or instance created by calling the given constructor
        */
        function createControlByURI(setting: string | any, constructor: any): sap.ui.core.Control;

        /**
         * Returns all names of registered collections in IconPool
         * @returns An array contains all of the registered collections' names.
        */
        function getIconCollectionNames(): any[];

        /**
         * Returns the icon url based on the given mime type
         * @since 1.25.0
         * @param sMimeType the mime type of a file (e.g. "application/zip")
         * @returns the icon url (e.g. "sap-icon://attachment-zip-file")
        */
        function getIconForMimeType(sMimeType: string): string;

        /**
         * Returns an info object for the icon with the given <code>iconName</code> and
         * <code>collectionName</code>.Instead of giving name and collection, a complete icon-URI can be
         * provided as <code>iconName</code>.The method will determine name and collection from the URI, see
         * {@link #.isIconURI IconPool.isIconURI}for details.The returned info object has the following
         * properties:<ul><li><code>string: name</code> Name of the icon</li><li><code>string:
         * collection</code> Name of the collection that contains the icon or <code>undefined</code> in case of
         * the default collection</li><li><code>string: uri</code> Icon URI that identifies the
         * icon</li><li><code>string: fontFamily</code> CSS font family to use for this
         * icon</li><li><code>string: content</code> Character sequence that represents the icon in the icon
         * font</li><li><code>string: text</code> Alternative text describing the icon (optional, might be
         * empty)</li><li><code>boolean: suppressMirroring</code> Whether the icon needs no mirroring in
         * right-to-left mode</li></ul>
         * @param iconName Name of the icon, must not be empty
         * @param collectionName Name of the icon collection; to access built-in icons, omit the collection
         * name
         * @returns Info object for the icon or <code>undefined</code> when the icon can't be found.
        */
        function getIconInfo(iconName: string, collectionName?: string): any;

        /**
         * Returns all name of icons that are registerd under the given collection.
         * @param collectionName the name of collection where icon names are retrieved.
         * @returns An array contains all of the registered icon names under the given collection.
        */
        function getIconNames(collectionName: string): any[];

        /**
         * Returns the URI of the icon in the pool which has the given <code>iconName</code> and
         * <code>collectionName</code>.
         * @param iconName Name of the icon, must not be empty
         * @param collectionName Name of the icon collection; to access built-in icons, omit the collection
         * name
         * @returns URI of the icon or <code>undefined</code> if the icon can't be found in the IconPool
        */
        function getIconURI(iconName: string, collectionName?: string): string;

        /**
         * Returns whether the given <code>uri</code> is an icon URI.A string is an icon URI when it can be
         * parsed as an URI and when it has one of the two
         * forms<ul><li>sap-icon://collectionName/iconName</li><li>sap-icon://iconName</li></ul>where
         * collectionName and iconName must be non-empty.
         * @param uri The URI to check
         * @returns Whether the URI matches the icon URI format
        */
        function isIconURI(uri: string): boolean;
      }
      namespace Collision {
      }
      namespace Percentage {
      }
      namespace Popup.Dock {

        /**
        */
        var BeginBottom: any;

        /**
        */
        var BeginCenter: any;

        /**
        */
        var BeginTop: any;

        /**
        */
        var CenterBottom: any;

        /**
        */
        var CenterCenter: any;

        /**
        */
        var CenterTop: any;

        /**
        */
        var EndBottom: any;

        /**
        */
        var EndCenter: any;

        /**
        */
        var EndTop: any;

        /**
        */
        var LeftBottom: any;

        /**
        */
        var LeftCenter: any;

        /**
        */
        var LeftTop: any;

        /**
        */
        var RightBottom: any;

        /**
        */
        var RightCenter: any;

        /**
        */
        var RightTop: any;
      }
      namespace ResizeHandler {

        /**
         * Deregisters a previously registered handler for resize events with the given registration ID.
         * @param sId The registration ID of the handler to deregister. The ID was provided by function {@link
         * sap.ui.core.ResizeHandler.register}           when the handler was registered.
        */
        function deregister(sId: string): void;


        /**
         * Returns a metadata object for class sap.ui.core.ResizeHandler.
         * @returns Metadata object describing this class
        */
        function getMetadata(): sap.ui.base.Metadata;

        /**
         * Registers the given event handler for resize events on the given DOM element or control.<b>Note:</b>
         * This function must not be used before the UI5 framework is initialized.Please use the {@link
         * sap.ui.core.Core#attachInit init event} of UI5 if you are not sure whether this is the case.The
         * resize handler periodically checks the dimensions of the registered reference. Whenever it detects
         * changes, an event is fired.Be careful when changing dimensions within the event handler which might
         * cause another resize event and so on.The available parameters of the resize event
         * are:<ul><li><code>oEvent.target</code>: The DOM element of which the dimensions were
         * checked</li><li><code>oEvent.size.width</code>: The current width of the DOM element in
         * pixels</li><li><code>oEvent.size.height</code>: The current height of the DOM element in
         * pixels</li><li><code>oEvent.oldSize.width</code>: The previous width of the DOM element in
         * pixels</li><li><code>oEvent.oldSize.height</code>: The previous height of the DOM element in
         * pixels</li><li><code>oEvent.control</code>: The control which was given during registration of the
         * event handler (if present)</li></ul>
         * @param oRef The control or the DOM reference for which the given event handler should be registered
         * (beside the window)
         * @param fHandler The event handler which should be called whenever the size of the given reference is
         * changed.            The event object is passed as first argument to the event handler. See the
         * description of this function for more details about the available parameters of this event.
         * @returns A registration ID which can be used for deregistering the event handler, see {@link
         * sap.ui.core.ResizeHandler.deregister}.            If the UI5 framework is not yet initialized
         * <code>null</code> is returned.
        */
        function register(oRef: any | sap.ui.core.Control, fHandler: any): string;
      }
      namespace BusyIndicator {

        /**
         * Registers a handler for the "close" event
         * @param fnFunction The function to call, when the event occurs.           This function will be
         * called on the oListener-instance (if           present) or in a 'static way'.
         * @param oListener Object on which to call the given function.
         * @returns <code>this</code> to allow method chaining
        */
        function attachClose(fnFunction: any, oListener?: any): typeof sap.ui.core.BusyIndicator;

        /**
         * Registers a handler for the "open" event.
         * @param fnFunction The function to call, when the event occurs. This           function will be
         * called on the oListener-instance (if present)           or in a 'static way'.
         * @param oListener Object on which to call the given function.
         * @returns <code>this</code> to allow method chaining
        */
        function attachOpen(fnFunction: any, oListener?: any): typeof sap.ui.core.BusyIndicator;

        /**
         * Unregisters a handler for the "close" event
         * @param fnFunction The callback function to unregister
         * @param oListener Object on which the given function had to be called.
         * @returns <code>this</code> to allow method chaining
        */
        function detachClose(fnFunction: any, oListener: any): typeof sap.ui.core.BusyIndicator;

        /**
         * Unregisters a handler for the "open" event
         * @param fnFunction The callback function to unregister
         * @param oListener Object on which the given function had to be called.
         * @returns <code>this</code> to allow method chaining
        */
        function detachOpen(fnFunction: any, oListener: any): typeof sap.ui.core.BusyIndicator;

        /**
         * Removes the BusyIndicator from the screen
        */
        function hide(): void;

        /**
         * Displays the BusyIndicator and starts blocking all user input.This only happens after some delay and
         * if after that delay theBusyIndicator.hide() has not yet been called in the meantime.There is a
         * certain default value for the delay, but that one can beoverridden.
         * @param iDelay The delay in milliseconds before opening the                      BusyIndicator. It is
         * not opened if hide() is called                      before end of the delay. If no delay (or no
         * valid                      delay) is given, the default value is used.
        */
        function show(iDelay: number): void;
        namespace tils {
        }
      }
      namespace Configuration {
        /**
         * Encapsulates configuration settings that are related to data formatting/parsing.<b>Note:</b> When
         * format configuration settings are modified through this class,UI5 only ensures that formatter
         * objects created after that point in time will honorthe modifications. To be on the safe side,
         * applications should do any modificationsearly in their lifecycle or recreate any model/UI that is
         * locale dependent.
         * @resource sap/ui/core/Configuration.js
        */
        export class FormatSettings extends sap.ui.base.Object {


          constructor();




          /**
           * Returns the currently set date pattern or undefined if no pattern has been defined.
          */
          getDatePattern(): void;

          /**
           * Returns the locale to be used for formatting.If no such locale has been defined, this method falls
           * back to the language,see {@link sap.ui.core.Configuration#getLanguage
           * Configuration.getLanguage()}.If any user preferences for date, time or number formatting have been
           * set,and if no format locale has been specified, then a special private use subtagis added to the
           * locale, indicating to the framework that these user preferencesshould be applied.
           * @returns the format locale
          */
          getFormatLocale(): sap.ui.core.Locale;

          /**
           * Returns the currently set customizing data for Islamic calendar support
           * @returns Returns an array contains the customizing data. Each element in the array has properties:
           * dateFormat, islamicMonthStart, gregDate. For details, please see {@link
           * #setLegacyDateCalendarCustomizing}
          */
          getLegacyDateCalendarCustomizing(): any[];

          /**
           * Returns the currently set legacy ABAP date format (its id) or undefined if none has been set.
          */
          getLegacyDateFormat(): void;

          /**
           * Returns the currently set legacy ABAP number format (its id) or undefined if none has been set.
          */
          getLegacyNumberFormat(): void;

          /**
           * Returns the currently set legacy ABAP time format (its id) or undefined if none has been set.
          */
          getLegacyTimeFormat(): void;

          /**
           * Returns a metadata object for class sap.ui.core.Configuration.FormatSettings.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Returns the currently set number symbol of the given type or undefined if no symbol has been
           * defined.
          */
          getNumberSymbol(): void;

          /**
           * Returns the currently set time pattern or undefined if no pattern has been defined.
          */
          getTimePattern(): void;

          /**
           * Defines the preferred format pattern for the given date format style.Calling this method with a null
           * or undefined pattern removes a previously set pattern.If a pattern is defined, it will be preferred
           * over patterns derived from the current locale.See class {@link sap.ui.core.format.DateFormat} for
           * details about the pattern syntax.After changing the date pattern, the framework tries to update
           * localizationspecific parts of the UI. See the documentation of {@link
           * sap.ui.core.Configuration#setLanguage}for details and restrictions.
           * @param sStyle must be one of short, medium, long or full.
           * @param sPattern the format pattern to be used in LDML syntax.
           * @returns Returns <code>this</code> to allow method chaining
          */
          setDatePattern(sStyle: string, sPattern: string): sap.ui.core.Configuration.FormatSettings;

          /**
           * Defines the day used as the first day of the week.The day is set as an integer value between 0
           * (Sunday) and 6 (Saturday).Calling this method with a null or undefined symbol removes a previously
           * set value.If a value is defined, it will be preferred over values derived from the current
           * locale.Usually in the US the week starts on Sunday while in most European countries on Monday.There
           * are special cases where you want to have the first day of week set independent of theuser
           * locale.After changing the first day of week, the framework tries to update localizationspecific
           * parts of the UI. See the documentation of {@link sap.ui.core.Configuration#setLanguage}for details
           * and restrictions.
           * @param iValue must be an integer value between 0 and 6
           * @returns Returns <code>this</code> to allow method chaining
          */
          setFirstDayOfWeek(iValue: number): sap.ui.core.Configuration.FormatSettings;

          /**
           * Allows to specify the customizing data for Islamic calendar support
           * @param aMappings contains the customizing data for the support of Islamic calendar.
           * @returns Returns <code>this</code> to allow method chaining
          */
          setLegacyDateCalendarCustomizing(aMappings: any[]): sap.ui.core.Configuration.FormatSettings;

          /**
           * Allows to specify one of the legacy ABAP date formats.This method modifies the date patterns for
           * 'short' and 'medium' style with the corresponding ABAPformat. When called with a null or undefined
           * format id, any previously applied format will be removed.After changing the legacy date format, the
           * framework tries to update localizationspecific parts of the UI. See the documentation of {@link
           * sap.ui.core.Configuration#setLanguage}for details and restrictions.Note: Iranian date format 'C' is
           * NOT yet supported by UI5. It's accepted by this method for convenience(user settings from ABAP
           * system can be used without filtering), but it's ignored. Instead, the formatsfrom the current format
           * locale will be used and a warning will be logged.
           * @param sFormatId id of the ABAP data format (one of '1','2','3','4','5','6','7','8','9','A','B','C')
           * @returns Returns <code>this</code> to allow method chaining
          */
          setLegacyDateFormat(sFormatId: string): sap.ui.core.Configuration.FormatSettings;

          /**
           * Allows to specify one of the legacy ABAP number format.This method will modify the 'group' and
           * 'decimal' symbols. When called with a nullor undefined format id, any previously applied format will
           * be removed.After changing the legacy number format, the framework tries to update
           * localizationspecific parts of the UI. See the documentation of {@link
           * sap.ui.core.Configuration#setLanguage}for details and restrictions.
           * @param sFormatId id of the ABAP number format set (one of ' ','X','Y')
           * @returns Returns <code>this</code> to allow method chaining
          */
          setLegacyNumberFormat(sFormatId: string): sap.ui.core.Configuration.FormatSettings;

          /**
           * Allows to specify one of the legacy ABAP time formats.This method sets the time patterns for 'short'
           * and 'medium' style to the corresponding ABAPformats and sets the day period texts to "AM"/"PM" or
           * "am"/"pm" respectively. When calledwith a null or undefined format id, any previously applied format
           * will be removed.After changing the legacy time format, the framework tries to update
           * localizationspecific parts of the UI. See the documentation of {@link
           * sap.ui.core.Configuration#setLanguage}for details and restrictions.
           * @param sFormatId id of the ABAP time format (one of '0','1','2','3','4')
           * @returns Returns <code>this</code> to allow method chaining
          */
          setLegacyTimeFormat(sFormatId: string): sap.ui.core.Configuration.FormatSettings;

          /**
           * Defines the string to be used for the given number symbol.Calling this method with a null or
           * undefined symbol removes a previously set symbol string.Note that an empty string is explicitly
           * allowed.If a symbol is defined, it will be preferred over symbols derived from the current
           * locale.See class {@link sap.ui.core.format.NumberFormat} for details about the symbols.After
           * changing the number symbol, the framework tries to update localizationspecific parts of the UI. See
           * the documentation of {@link sap.ui.core.Configuration#setLanguage}for details and restrictions.
           * @param sStyle must be one of decimal, group, plusSign, minusSign.
           * @param sSymbol will be used to represent the given symbol type
           * @returns Returns <code>this</code> to allow method chaining
          */
          setNumberSymbol(sStyle: string, sSymbol: string): sap.ui.core.Configuration.FormatSettings;

          /**
           * Defines the preferred format pattern for the given time format style.Calling this method with a null
           * or undefined pattern removes a previously set pattern.If a pattern is defined, it will be preferred
           * over patterns derived from the current locale.See class {@link sap.ui.core.format.DateFormat} for
           * details about the pattern syntax.After changing the time pattern, the framework tries to update
           * localizationspecific parts of the UI. See the documentation of {@link
           * sap.ui.core.Configuration#setLanguage}for details and restrictions.
           * @param sStyle must be one of short, medium, long or full.
           * @param sPattern the format pattern to be used in LDML syntax.
           * @returns Returns <code>this</code> to allow method chaining
          */
          setTimePattern(sStyle: string, sPattern: string): sap.ui.core.Configuration.FormatSettings;
        }
      }
      namespace AppCacheBuster {

        /**
         * Converts the given URL if it matches a URL in the cachebuster index.If not then the same URL will be
         * returned. To prevent URLs from beingmodified by the application cachebuster you can implement the
         * function<code>sap.ui.core.AppCacheBuster.handleURL</code>.
         * @param sUrl any URL
         * @returns modified URL when matching the index or unmodified when not
        */
        function convertURL(sUrl: string): string;

        /**
         * Callback function which can be overwritten to programmatically decidewhether to rewrite the given
         * URL or not.
         * @param sUrl any URL
         * @returns <code>true</code> to rewrite or <code>false</code> to ignore
        */
        function handleURL(sUrl: string): boolean;

        /**
         * Normalizes the given URL and make it absolute.
         * @param sUrl any URL
         * @returns normalized URL
        */
        function normalizeURL(sUrl: string): string;

        /**
         * Registers an application. Loads the cachebuster index file from thislocations. All registered files
         * will be considered by the cachebusterand the URLs will be prefixed with the timestamp of the index
         * file.
         * @param base URL of an application providing a cachebuster index file
        */
        function register(base: string): void;
      }
      namespace LabelEnablement {

        /**
         * This function should be called on a label control to enrich it's functionality.<b>Usage:</b>The
         * function can be called with a control
         * prototype:<code>sap.ui.core.LabelEnablement.enrich(my.Label.prototype);</code>Or the function can be
         * called on instance level in the init function of a label control:<code>my.Label.prototype.init:
         * function(){   sap.ui.core.LabelEnablement.enrich(this);}</code><b>Preconditions:</b>The given
         * control must implement the interface sap.ui.core.Label and have an association 'labelFor' with
         * cardinality 0..1.This function extends existing API functions. Ensure not to override this
         * extensions AFTER calling this function.<b>What does this function do?</b>A mechanismn is added that
         * ensures that a bidirectional reference between the label and it's labeled control is established:The
         * label references the labeled control via the html 'for' attribute (@see
         * sap.ui.core.LabelEnablement#writeLabelForAttribute).If the labeled control supports the
         * aria-labelledby attribute. A reference to the label is added automatically.In addition an
         * alternative to apply a for reference without influencing the labelFor association of the API is
         * applied (e.g. used by Form).For this purpose the functions setAlternativeLabelFor and
         * getLabelForRendering are added.
         * @param oControl the label control which should be enriched with further label functionality.
        */
        function enrich(oControl: sap.ui.core.Control): void;

        /**
         * Returns an array of ids of the labels referencing the given element
         * @param oElement The element whose referencing labels should be returned
         * @returns an array of ids of the labels referencing the given element
        */
        function getReferencingLabels(oElement: sap.ui.core.Element): string[];

        /**
         * Returns <code>true</code> when the given control is required (property 'required') or one of its
         * referencing labels, <code>false</code> otherwise.
         * @since 1.29.0
         * @param oElement The element which should be checked for its required state
         * @returns <code>true</code> when the given control is required (property 'required') or one of its
         * referencing labels, <code>false</code> otherwise
        */
        function isRequired(oElement: sap.ui.core.Element): boolean;

        /**
         * Helper function for the label control to render the html 'for' attribute. This function should be
         * calledat the desired location in the renderer code of the label control.
         * @param oRenderManager The RenderManager that can be used for writing to the render-output-buffer.
         * @param oLabel The label for which the 'for' html attribute should be written to the
         * render-output-buffer.
        */
        function writeLabelForAttribute(oRenderManager: sap.ui.core.RenderManager, oLabel: any): void;
      }
      namespace ValueStateSupport {

        /**
         * Appends a generic success, warning or error message to the given tooltip text if the given
         * Elementhas a property "valueState" with one of these three states.
         * @param oElement the Element of which the tooltip needs to be modified
         * @param sTooltipText the original tooltip text (may be null)
         * @returns the given text, with appended success/warning/error text, if appropriate
        */
        function enrichTooltip(oElement: sap.ui.core.Element, sTooltipText: string): string;

        /**
         * Returns a ValueState object based on the given integer value 0 : ValueState.None 1 :
         * ValueState.Warning 2 : ValueState.Success 3 : ValueState.Error
         * @since 1.25.0
         * @param iState the state as an integer
         * @returns the corresponding ValueState object
        */
        function formatValueState(iState: number): sap.ui.core.ValueState;

        /**
         * Returns a generic success, warning or error message if the given Elementhas a property "valueState"
         * with one of these three states or the given ValueStaterepresents one of these states.
         * @param vValue the Element of which the valueState needs to be checked, or the ValueState explicitly
         * @returns the success/warning/error text, if appropriate; otherwise null
        */
        function getAdditionalText(vValue: sap.ui.core.Element | sap.ui.core.ValueState): string;
      }
      /**
       * A control base type.
       * @resource sap/ui/core/Item.js
      */
      export class Item extends sap.ui.core.Element {


        /**
         * Constructor for a new Item.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);




        /**
         * Gets current value of property <code>enabled</code>.Enabled items can be selected.Default value is
         * <code>true</code>.
         * @returns Value of property <code>enabled</code>
        */
        getEnabled(): boolean;

        /**
         * Gets current value of property <code>key</code>.Can be used as input for subsequent actions.
         * @returns Value of property <code>key</code>
        */
        getKey(): string;

        /**
         * Returns a metadata object for class sap.ui.core.Item.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>text</code>.The text to be displayed for the item.Default value
         * is <code></code>.
         * @returns Value of property <code>text</code>
        */
        getText(): string;

        /**
         * Gets current value of property <code>textDirection</code>.Options are RTL and LTR. Alternatively, an
         * item can inherit its text direction from its parent control.Default value is <code>Inherit</code>.
         * @returns Value of property <code>textDirection</code>
        */
        getTextDirection(): sap.ui.core.TextDirection;

        /**
         * Sets a new value for property <code>enabled</code>.Enabled items can be selected.When called with a
         * value of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>true</code>.
         * @param bEnabled New value for property <code>enabled</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setEnabled(bEnabled: boolean): sap.ui.core.Item;

        /**
         * Sets a new value for property <code>key</code>.Can be used as input for subsequent actions.When
         * called with a value of <code>null</code> or <code>undefined</code>, the default value of the
         * property will be restored.
         * @param sKey New value for property <code>key</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setKey(sKey: string): sap.ui.core.Item;

        /**
         * Sets a new value for property <code>text</code>.The text to be displayed for the item.When called
         * with a value of <code>null</code> or <code>undefined</code>, the default value of the property will
         * be restored.Default value is <code></code>.
         * @param sText New value for property <code>text</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setText(sText: string): sap.ui.core.Item;

        /**
         * Sets a new value for property <code>textDirection</code>.Options are RTL and LTR. Alternatively, an
         * item can inherit its text direction from its parent control.When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>Inherit</code>.
         * @param sTextDirection New value for property <code>textDirection</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setTextDirection(sTextDirection: sap.ui.core.TextDirection): sap.ui.core.Item;
      }
      /**
       * Icon uses embedded font instead of pixel image. Comparing to image, Icon is easily scalable, color
       * can be altered live and various effects can be added using css.A set of built in Icons is available
       * and they can be fetched by calling sap.ui.core.IconPool.getIconURI and set this value to the src
       * property on the Icon.
       * @resource sap/ui/core/Icon.js
      */
      export class Icon extends sap.ui.core.Control {


        /**
         * Constructor for a new Icon.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Adds some ariaLabelledBy into the association <code>ariaLabelledBy</code>.
         * @param vAriaLabelledBy the ariaLabelledBy to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addAriaLabelledBy(vAriaLabelledBy: any | sap.ui.core.Control): sap.ui.core.Icon;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>press</code> event of this
         * <code>sap.ui.core.Icon</code>.When called, the context of the event handler (its <code>this</code>)
         * will be bound to <code>oListener</code> if specified, otherwise it will be bound to this
         * <code>sap.ui.core.Icon</code> itself.This event is fired when icon is pressed/activated by the user.
         * When a handler is attached to this event, the Icon gets tab stop. If you want to disable this
         * behavior, set the noTabStop property to true.
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.core.Icon</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachPress(oData: any, fnFunction: any, oListener?: any): sap.ui.core.Icon;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>press</code> event of this
         * <code>sap.ui.core.Icon</code>.The passed function and listener object must match the ones used for
         * event registration.
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachPress(fnFunction: any, oListener: any): sap.ui.core.Icon;


        /**
         * Fires event <code>press</code> to attached listeners.
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        firePress(mArguments: any): sap.ui.core.Icon;

        /**
        */
        getAccessibilityInfo(): void;

        /**
         * Gets current value of property <code>activeBackgroundColor</code>.Background color for Icon in
         * active state.
         * @returns Value of property <code>activeBackgroundColor</code>
        */
        getActiveBackgroundColor(): string;

        /**
         * Gets current value of property <code>activeColor</code>.This color is shown when icon is
         * pressed/activated by the user.
         * @returns Value of property <code>activeColor</code>
        */
        getActiveColor(): string;

        /**
         * Gets current value of property <code>alt</code>.This defines the alternative text which is used for
         * outputting the aria-label attribute on the DOM.
         * @since 1.30.0
         * @returns Value of property <code>alt</code>
        */
        getAlt(): string;

        /**
         * Returns array of IDs of the elements which are the current targets of the association
         * <code>ariaLabelledBy</code>.
        */
        getAriaLabelledBy(): any[];

        /**
         * Gets current value of property <code>backgroundColor</code>.Background color of the Icon in normal
         * state.
         * @returns Value of property <code>backgroundColor</code>
        */
        getBackgroundColor(): string;

        /**
         * Gets current value of property <code>color</code>.The color of the Icon. If color is not defined
         * here, the Icon inherits the color from its DOM parent.
         * @returns Value of property <code>color</code>
        */
        getColor(): string;

        /**
         * Gets current value of property <code>decorative</code>.A decorative icon is included for design
         * reasons. Accessibility tools will ignore decorative icons. Tab stop isn't affected by this property
         * anymore and it's now controlled by the existence of press event handler and the noTabStop
         * property.Default value is <code>true</code>.
         * @since 1.16.4
         * @returns Value of property <code>decorative</code>
        */
        getDecorative(): boolean;

        /**
         * Gets current value of property <code>height</code>.This is the height of the DOM element which
         * contains the Icon. Setting this property doesn't affect the size of the font. If you want to make
         * the font bigger, increase the size property.
         * @returns Value of property <code>height</code>
        */
        getHeight(): any;

        /**
         * Gets current value of property <code>hoverBackgroundColor</code>.Background color for Icon in hover
         * state. This property has no visual effect when run on mobile device.
         * @returns Value of property <code>hoverBackgroundColor</code>
        */
        getHoverBackgroundColor(): string;

        /**
         * Gets current value of property <code>hoverColor</code>.This color is shown when icon is hovered.
         * This property has no visual effect when run on mobile device.
         * @returns Value of property <code>hoverColor</code>
        */
        getHoverColor(): string;

        /**
         * Returns a metadata object for class sap.ui.core.Icon.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>noTabStop</code>.Defines whether the tab stop of icon is
         * controlled by the existence of press event handler. When it's set to false, Icon control has tab
         * stop when press event handler is attached.If it's set to true, Icon control never has tab stop no
         * matter whether press event handler exists or not.Default value is <code>false</code>.
         * @since 1.30.1
         * @returns Value of property <code>noTabStop</code>
        */
        getNoTabStop(): boolean;

        /**
         * Gets current value of property <code>size</code>.Since Icon uses font, this property will be applied
         * to the css font-size property on the rendered DOM element.
         * @returns Value of property <code>size</code>
        */
        getSize(): any;

        /**
         * Gets current value of property <code>src</code>.This property should be set by the return value of
         * calling sap.ui.core.IconPool.getIconURI with a Icon name parameter and an optional collection
         * parameter which is required when using application extended Icons. A list of standard FontIcon is
         * available here.
         * @returns Value of property <code>src</code>
        */
        getSrc(): any;

        /**
         * Gets current value of property <code>useIconTooltip</code>.Decides whether a default Icon tooltip
         * should be used if no tooltip is set.Default value is <code>true</code>.
         * @since 1.30.0
         * @returns Value of property <code>useIconTooltip</code>
        */
        getUseIconTooltip(): boolean;

        /**
         * Gets current value of property <code>width</code>.This is the width of the DOM element which
         * contains the Icon. Setting this property doesn't affect the size of the font. If you want to make
         * the font bigger, increase the size property.
         * @returns Value of property <code>width</code>
        */
        getWidth(): any;

        /**
         * Removes all the controls in the association named <code>ariaLabelledBy</code>.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllAriaLabelledBy(): any[];

        /**
         * Removes an ariaLabelledBy from the association named <code>ariaLabelledBy</code>.
         * @param vAriaLabelledBy The ariaLabelledBy to be removed or its index or ID
         * @returns The removed ariaLabelledBy or <code>null</code>
        */
        removeAriaLabelledBy(vAriaLabelledBy: number | any | sap.ui.core.Control): any;

        /**
         * Sets a new value for property <code>activeBackgroundColor</code>.Background color for Icon in active
         * state.When called with a value of <code>null</code> or <code>undefined</code>, the default value of
         * the property will be restored.
         * @param sActiveBackgroundColor New value for property <code>activeBackgroundColor</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setActiveBackgroundColor(sActiveBackgroundColor: string): sap.ui.core.Icon;

        /**
         * Sets a new value for property <code>activeColor</code>.This color is shown when icon is
         * pressed/activated by the user.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.
         * @param sActiveColor New value for property <code>activeColor</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setActiveColor(sActiveColor: string): sap.ui.core.Icon;

        /**
         * Sets a new value for property <code>alt</code>.This defines the alternative text which is used for
         * outputting the aria-label attribute on the DOM.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.
         * @since 1.30.0
         * @param sAlt New value for property <code>alt</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setAlt(sAlt: string): sap.ui.core.Icon;

        /**
         * Sets a new value for property <code>backgroundColor</code>.Background color of the Icon in normal
         * state.When called with a value of <code>null</code> or <code>undefined</code>, the default value of
         * the property will be restored.
         * @param sBackgroundColor New value for property <code>backgroundColor</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setBackgroundColor(sBackgroundColor: string): sap.ui.core.Icon;

        /**
         * Sets a new value for property <code>color</code>.The color of the Icon. If color is not defined
         * here, the Icon inherits the color from its DOM parent.When called with a value of <code>null</code>
         * or <code>undefined</code>, the default value of the property will be restored.
         * @param sColor New value for property <code>color</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setColor(sColor: string): sap.ui.core.Icon;

        /**
         * Sets a new value for property <code>decorative</code>.A decorative icon is included for design
         * reasons. Accessibility tools will ignore decorative icons. Tab stop isn't affected by this property
         * anymore and it's now controlled by the existence of press event handler and the noTabStop
         * property.When called with a value of <code>null</code> or <code>undefined</code>, the default value
         * of the property will be restored.Default value is <code>true</code>.
         * @since 1.16.4
         * @param bDecorative New value for property <code>decorative</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setDecorative(bDecorative: boolean): sap.ui.core.Icon;

        /**
         * Sets a new value for property <code>height</code>.This is the height of the DOM element which
         * contains the Icon. Setting this property doesn't affect the size of the font. If you want to make
         * the font bigger, increase the size property.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.
         * @param sHeight New value for property <code>height</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setHeight(sHeight: any): sap.ui.core.Icon;

        /**
         * Sets a new value for property <code>hoverBackgroundColor</code>.Background color for Icon in hover
         * state. This property has no visual effect when run on mobile device.When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
         * @param sHoverBackgroundColor New value for property <code>hoverBackgroundColor</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setHoverBackgroundColor(sHoverBackgroundColor: string): sap.ui.core.Icon;

        /**
         * Sets a new value for property <code>hoverColor</code>.This color is shown when icon is hovered. This
         * property has no visual effect when run on mobile device.When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
         * @param sHoverColor New value for property <code>hoverColor</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setHoverColor(sHoverColor: string): sap.ui.core.Icon;

        /**
         * Sets a new value for property <code>noTabStop</code>.Defines whether the tab stop of icon is
         * controlled by the existence of press event handler. When it's set to false, Icon control has tab
         * stop when press event handler is attached.If it's set to true, Icon control never has tab stop no
         * matter whether press event handler exists or not.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.Default value is
         * <code>false</code>.
         * @since 1.30.1
         * @param bNoTabStop New value for property <code>noTabStop</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setNoTabStop(bNoTabStop: boolean): sap.ui.core.Icon;

        /**
         * Sets a new value for property <code>size</code>.Since Icon uses font, this property will be applied
         * to the css font-size property on the rendered DOM element.When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
         * @param sSize New value for property <code>size</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setSize(sSize: any): sap.ui.core.Icon;

        /**
         * Sets a new value for property <code>src</code>.This property should be set by the return value of
         * calling sap.ui.core.IconPool.getIconURI with a Icon name parameter and an optional collection
         * parameter which is required when using application extended Icons. A list of standard FontIcon is
         * available here.When called with a value of <code>null</code> or <code>undefined</code>, the default
         * value of the property will be restored.
         * @param sSrc New value for property <code>src</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setSrc(sSrc: any): sap.ui.core.Icon;

        /**
         * Sets a new value for property <code>useIconTooltip</code>.Decides whether a default Icon tooltip
         * should be used if no tooltip is set.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.Default value is
         * <code>true</code>.
         * @since 1.30.0
         * @param bUseIconTooltip New value for property <code>useIconTooltip</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setUseIconTooltip(bUseIconTooltip: boolean): sap.ui.core.Icon;

        /**
         * Sets a new value for property <code>width</code>.This is the width of the DOM element which contains
         * the Icon. Setting this property doesn't affect the size of the font. If you want to make the font
         * bigger, increase the size property.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.
         * @param sWidth New value for property <code>width</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setWidth(sWidth: any): sap.ui.core.Icon;
      }
      /**
       * Embeds standard HTML in a SAPUI5 control tree.Security Hint: By default, the HTML content (property
       * 'content') is not sanitized and thereforeopen to XSS attacks. Applications that want to show user
       * defined input in an HTML control, shouldeither sanitize the content on their own or activate
       * automatic sanitizing through the{@link #setSanitizeContent sanitizeContent} property.Although this
       * control inherits the <code>tooltip</code> aggregation/property and the<code>hasStyleClass</code>,
       * <code>addStyleClass</code>, <code>removeStyleClass</code> and<code>toggleStyleClass</code> methods
       * from its base class, it doesn't support them.Instead, the defined HTML content can contain a tooltip
       * (title attribute) or custom CSS classes.For further hints about usage restrictions for this control,
       * see also the documentation of the<code>content</code> property.
       * @resource sap/ui/core/HTML.js
      */
      export class HTML extends sap.ui.core.Control {


        /**
         * Constructor for a new HTML.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Attaches event handler <code>fnFunction</code> to the <code>afterRendering</code> event of this
         * <code>sap.ui.core.HTML</code>.When called, the context of the event handler (its <code>this</code>)
         * will be bound to <code>oListener</code> if specified, otherwise it will be bound to this
         * <code>sap.ui.core.HTML</code> itself.Fired after the HTML control has been rendered. Allows to
         * manipulate the resulting DOM.When the control doesn't have string content and no preserved DOM
         * existed for this control,then this event will fire, but there won't be a DOM node for this control.
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.core.HTML</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachAfterRendering(oData: any, fnFunction: any, oListener?: any): sap.ui.core.HTML;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>afterRendering</code> event of this
         * <code>sap.ui.core.HTML</code>.The passed function and listener object must match the ones used for
         * event registration.
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachAfterRendering(fnFunction: any, oListener: any): sap.ui.core.HTML;


        /**
         * Fires event <code>afterRendering</code> to attached listeners.Expects the following event
         * parameters:<ul><li><code>isPreservedDOM</code> of type <code>boolean</code>Whether the current DOM
         * of the control has been preserved (true) or not (e.g.rendered from content property or it is an
         * empty HTML control).</li></ul>
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireAfterRendering(mArguments: any): sap.ui.core.HTML;

        /**
         * Gets current value of property <code>content</code>.HTML content to be displayed, defined as a
         * string.The content is converted to DOM nodes with a call to <code>new jQuery(content)</code>, so
         * anyrestrictions for the jQuery constructor apply to the content of the HTML control as well.Some of
         * these restrictions (there might be others!) are:<ul><li>the content must be enclosed in tags, pure
         * text is not supported. </li><li>if the content contains script tags, they will be executed but they
         * will not appear in the    resulting DOM tree. When the contained code tries to find the
         * corresponding script tag,    it will fail.</li></ul>Please consider to consult the jQuery
         * documentation as well.The HTML control currently doesn't prevent the usage of multiple root nodes in
         * its DOM content(e.g. <code>setContent("&lt;div/>&lt;div/>")</code>), but this is not a guaranteed
         * feature.The accepted content might be restricted to single root nodes in future versions.To notify
         * applications about this fact, a warning is written in the log when multiple root nodes are used.
         * @returns Value of property <code>content</code>
        */
        getContent(): string;

        /**
         * @param sSuffix Suffix of the Element to be retrieved or empty
         * @returns The element's DOM reference or null
        */
        getDomRef(sSuffix: string): sap.ui.core.Element;

        /**
         * Returns a metadata object for class sap.ui.core.HTML.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>preferDOM</code>.Whether existing DOM content is preferred over
         * the given content string.There are two scenarios where this flag is relevant (when set to
         * true):<ul><li>for the initial rendering: when an HTML control is added to an UIArea for the first
         * time    and if the root node of that UIArea contained DOM content with the same id as the HTML   
         * control, then that content will be used for rendering instead of any specified string   
         * content</li><li>any follow-up rendering: when an HTML control is rendered for the second or any
         * later    time and the preferDOM flag is set, then the DOM from the first rendering is preserved   
         * and not replaced by the string content</li></ul>As preserving the existing DOM is the most common
         * use case of the HTML control, the default value is true.Default value is <code>true</code>.
         * @returns Value of property <code>preferDOM</code>
        */
        getPreferDOM(): boolean;

        /**
         * Gets current value of property <code>sanitizeContent</code>.Whether to run the HTML sanitizer once
         * the content (HTML markup) is applied or not.To configure allowed URLs please use the whitelist API
         * via jQuery.sap.addUrlWhitelist.Default value is <code>false</code>.
         * @returns Value of property <code>sanitizeContent</code>
        */
        getSanitizeContent(): boolean;

        /**
         * Gets current value of property <code>visible</code>.Specifies whether the control is visible.
         * Invisible controls are not rendered.Default value is <code>true</code>.
         * @returns Value of property <code>visible</code>
        */
        getVisible(): boolean;

        /**
         * Sets a new value for property <code>content</code>.HTML content to be displayed, defined as a
         * string.The content is converted to DOM nodes with a call to <code>new jQuery(content)</code>, so
         * anyrestrictions for the jQuery constructor apply to the content of the HTML control as well.Some of
         * these restrictions (there might be others!) are:<ul><li>the content must be enclosed in tags, pure
         * text is not supported. </li><li>if the content contains script tags, they will be executed but they
         * will not appear in the    resulting DOM tree. When the contained code tries to find the
         * corresponding script tag,    it will fail.</li></ul>Please consider to consult the jQuery
         * documentation as well.The HTML control currently doesn't prevent the usage of multiple root nodes in
         * its DOM content(e.g. <code>setContent("&lt;div/>&lt;div/>")</code>), but this is not a guaranteed
         * feature.The accepted content might be restricted to single root nodes in future versions.To notify
         * applications about this fact, a warning is written in the log when multiple root nodes are used.When
         * called with a value of <code>null</code> or <code>undefined</code>, the default value of the
         * property will be restored.
         * @param sContent New value for property <code>content</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setContent(sContent: string): sap.ui.core.HTML;

        /**
         * Sets some new DOM content for this HTML control. The content will replace the existing contentafter
         * the next rendering. Properties are not modified, but preferDOM should be set to true.
         * @param oDom the new DOM content
         * @returns <code>this</code> to facilitate method chaining
        */
        setDOMContent(oDom: sap.ui.core.Element): sap.ui.core.HTML;

        /**
         * Sets a new value for property <code>preferDOM</code>.Whether existing DOM content is preferred over
         * the given content string.There are two scenarios where this flag is relevant (when set to
         * true):<ul><li>for the initial rendering: when an HTML control is added to an UIArea for the first
         * time    and if the root node of that UIArea contained DOM content with the same id as the HTML   
         * control, then that content will be used for rendering instead of any specified string   
         * content</li><li>any follow-up rendering: when an HTML control is rendered for the second or any
         * later    time and the preferDOM flag is set, then the DOM from the first rendering is preserved   
         * and not replaced by the string content</li></ul>As preserving the existing DOM is the most common
         * use case of the HTML control, the default value is true.When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>true</code>.
         * @param bPreferDOM New value for property <code>preferDOM</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setPreferDOM(bPreferDOM: boolean): sap.ui.core.HTML;

        /**
         * Sets a new value for property <code>sanitizeContent</code>.Whether to run the HTML sanitizer once
         * the content (HTML markup) is applied or not.To configure allowed URLs please use the whitelist API
         * via jQuery.sap.addUrlWhitelist.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.Default value is
         * <code>false</code>.
         * @param bSanitizeContent New value for property <code>sanitizeContent</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setSanitizeContent(bSanitizeContent: boolean): sap.ui.core.HTML;

        /**
         * Sets a new value for property <code>visible</code>.Specifies whether the control is visible.
         * Invisible controls are not rendered.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.Default value is
         * <code>true</code>.
         * @param bVisible New value for property <code>visible</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setVisible(bVisible: boolean): sap.ui.core.HTML;
      }
      /**
       * Core Class of the SAP UI Library.This class boots the Core framework and makes it available for the
       * Applicationvia the method <code>sap.ui.getCore()</code>.Example:<br/><pre>   var oCore =
       * sap.ui.getCore();</pre><br/>It provides events where the Application can attach
       * to.<br/>Example:<br/><pre>oCore.attachInit(function () {  //do the needful, do it
       * lean});</pre><br/>It registers the Browser Eventing.
       * @resource sap/ui/core/Core.js
      */
      export class Core extends sap.ui.base.Object {


        constructor();



        /**
         * Enforces an immediate update of the visible UI (aka "rendering").In general, applications should
         * avoid calling this method andinstead let the framework manage any necessary rendering.
        */
        applyChanges(): void;

        /**
         * Applies the theme with the given name (by loading the respective style sheets, which does not
         * disrupt the application).By default, the theme files are expected to be located at path relative to
         * the respective control library ([libraryLocation]/themes/[themeName]).Different locations can be
         * configured by using the method setThemePath() or by using the second parameter "sThemeBaseUrl" of
         * applyTheme().Usage of this second parameter is a shorthand for setThemePath and internally calls
         * setThemePath, so the theme location is then known.sThemeBaseUrl is a single URL to specify the
         * default location of all theme files. This URL is the base folder below which the control library
         * foldersare located. E.g. if the CSS files are not located relative to the root location of UI5, but
         * instead they are at locations like  
         * http://my.server/myapp/resources/sap/ui/core/themes/my_theme/library.cssthen the URL that needs to
         * be given is:   http://my.server/myapp/resourcesAll theme resources are then loaded from below this
         * folder - except if for a certain library a different location has been registered.If the theme
         * resources are not all either below this base location or  with their respective libraries, then
         * setThemePath must beused to configure individual locations.
         * @param sThemeName the name of the theme to be loaded
         * @param sThemeBaseUrl the (optional) base location of the theme
        */
        applyTheme(sThemeName: string, sThemeBaseUrl?: string): void;

        /**
         * Registers a listener for control events.
         * @param fnFunction callback to be called for each control event
         * @param oListener optional context object to call the callback on.
        */
        attachControlEvent(fnFunction: any, oListener?: any): void;

        /**
         * Attach event-handler <code>fnFunction</code> to the 'formatError' event of
         * <code>sap.ui.core.Core</code>.<br/>Please note that this event is a bubbling event and may already
         * be canceled before reaching the core.<br/>
         * @param fnFunction The function to call, when the event occurs. This function will be called on the  
         *         oListener-instance (if present) or in a 'static way'.
         * @param oListener Object on which to call the given function. If empty, this Model is used.
         * @returns <code>this</code> to allow method chaining
        */
        attachFormatError(fnFunction: any, oListener?: any): sap.ui.core.Core;

        /**
         * Attaches a given function to the <code>initEvent</code> event of the core.The given callback
         * function will either be called once the Core has been initializedor, if it has been initialized
         * already, it will be called immediately.
         * @since 1.13.2
         * @param fnFunction the callback function to be called on event firing.
        */
        attachInit(fnFunction: any): void;

        /**
         * Attaches a given function to the <code>initEvent</code> event of the core.This event will only be
         * fired once; you can check if it has been fired alreadyby calling {@link #isInitialized}.
         * @param fnFunction the function to be called on event firing.
        */
        attachInitEvent(fnFunction: any): void;

        /**
         * Registers a listener to the central interval timer.
         * @since 1.16.0
         * @param fnFunction callback to be called periodically
         * @param oListener optional context object to call the callback on.
        */
        attachIntervalTimer(fnFunction: any, oListener?: any): void;

        /**
         * Register a listener for the <code>localizationChanged</code> event.
         * @param fnFunction callback to be called
         * @param oListener context object to cal lthe function on.
        */
        attachLocalizationChanged(fnFunction: any, oListener: any): void;

        /**
         * Attach event-handler <code>fnFunction</code> to the 'parseError' event of
         * <code>sap.ui.core.Core</code>.<br/>Please note that this event is a bubbling event and may already
         * be canceled before reaching the core.<br/>
         * @param oData The object, that should be passed along with the event-object when firing the event
         * @param fnFunction The function to call, when the event occurs. This function will be called on the  
         *         oListener-instance (if present) or in a 'static way'.
         * @param oListener Object on which to call the given function. If empty, this Model is used.
         * @returns <code>this</code> to allow method chaining
        */
        attachParseError(oData: any, fnFunction: any, oListener?: any): sap.ui.core.Core;

        /**
         * Attach event-handler <code>fnFunction</code> to the 'validationError' event of
         * <code>sap.ui.core.Core</code>.<br/>Please note that this event is a bubbling event and may already
         * be canceled before reaching the core.<br/>
         * @param oData The object, that should be passed along with the event-object when firing the event
         * @param fnFunction The function to call, when the event occurs. This function will be called on the  
         *         oListener-instance (if present) or in a 'static way'.
         * @param oListener Object on which to call the given function. If empty, this Model is used.
         * @returns <code>this</code> to allow method chaining
        */
        attachValidationError(oData: any, fnFunction: any, oListener?: any): sap.ui.core.Core;

        /**
         * Attach event-handler <code>fnFunction</code> to the 'validationSuccess' event of
         * <code>sap.ui.core.Core</code>.<br/>Please note that this event is a bubbling event and may already
         * be canceled before reaching the core.<br/>
         * @param oData The object, that should be passed along with the event-object when firing the event
         * @param fnFunction The function to call, when the event occurs. This function will be called on the  
         *         oListener-instance (if present) or in a 'static way'.
         * @param oListener Object on which to call the given function. If empty, this Model is used.
         * @returns <code>this</code> to allow method chaining
        */
        attachValidationSuccess(oData: any, fnFunction: any, oListener?: any): sap.ui.core.Core;

        /**
         * Returns a list of all controls with a field group ID.See {@link
         * sap.ui.core.Control#checkFieldGroupIds Control.prototype.checkFieldGroupIds} for a description of
         * the<code>vFieldGroupIds</code> parameter.
         * @param vFieldGroupIds ID of the field group or an array of field group IDs to match
         * @returns The list of controls with matching field group IDs
        */
        byFieldGroupId(vFieldGroupIds: string | string[]): sap.ui.core.Control[];

        /**
         * Returns the registered element for the given id, if any.
         * @param sId undefined
         * @returns the element for the given id
        */
        byId(sId: string): sap.ui.core.Element;

        /**
         * Creates a component with the provided id and settings.When the optional parameter <code>sUrl</code>
         * is given, then all request for resources of thelibrary will be redirected to the given Url. This is
         * convenience for a call to<pre>  jQuery.sap.registerModulePath(sName, sUrl);</pre>
         * @param vComponent name of the component to import or object containing all needed parameters
         * @param sUrl the URL to load the component from
         * @param sId the ID for the component instance
         * @param mSettings the settings object for the component
        */
        createComponent(vComponent: string | any, sUrl?: string, sId?: string, mSettings?: any): void;

        /**
         * Returns a new instance of the RenderManager interface.
         * @returns the new instance of the RenderManager interface.
        */
        createRenderManager(): sap.ui.core.RenderManager;

        /**
         * Creates a new sap.ui.core.UIArea.
         * @param oDomRef a DOM Element or ID string of the UIArea
         * @returns a new UIArea
        */
        createUIArea(oDomRef: string | sap.ui.core.Element): sap.ui.core.UIArea;

        /**
         * Unregisters a listener for control events.A listener will only be unregistered if the same
         * function/context combinationis given as in the attachControlEvent call.
         * @param fnFunction function to unregister
         * @param oListener context object given during registration
        */
        detachControlEvent(fnFunction: any, oListener?: any): void;

        /**
         * Detach event-handler <code>fnFunction</code> from the 'formatError' event of
         * <code>sap.ui.core.Core</code>.<br/>The passed function and listener object must match the ones
         * previously used for event registration.
         * @param fnFunction The callback function to unregister
         * @param oListener Object on which the given function had to be called.
         * @returns <code>this</code> to allow method chaining
        */
        detachFormatError(fnFunction: any, oListener: any): sap.ui.core.Core;

        /**
         * Unregisters a listener for the central interval timer.A listener will only be unregistered if the
         * same function/context combinationis given as in the attachIntervalTimer call.
         * @since 1.16.0
         * @param fnFunction function to unregister
         * @param oListener context object given during registration
        */
        detachIntervalTimer(fnFunction: any, oListener?: any): void;

        /**
         * Unregister a listener from the <code>localizationChanged</code> event.The listener will only be
         * unregistered if the same function/context combinationis given as in the call to
         * <code>attachLocalizationListener</code>.
         * @param fnFunction callback to be deregistered
         * @param oListener context object given in a previous call to attachLocalizationChanged.
        */
        detachLocalizationChanged(fnFunction: any, oListener: any): void;

        /**
         * Detach event-handler <code>fnFunction</code> from the 'parseError' event of
         * <code>sap.ui.core.Core</code>.<br/>The passed function and listener object must match the ones
         * previously used for event registration.
         * @param fnFunction The callback function to unregister.
         * @param oListener Object on which the given function had to be called.
         * @returns <code>this</code> to allow method chaining
        */
        detachParseError(fnFunction: any, oListener: any): sap.ui.core.Core;

        /**
         * Detach event-handler <code>fnFunction</code> from the 'validationError' event of
         * <code>sap.ui.core.Core</code>.<br/>The passed function and listener object must match the ones
         * previously used for event registration.
         * @param fnFunction The callback function to unregister
         * @param oListener Object on which the given function had to be called.
         * @returns <code>this</code> to allow method chaining
        */
        detachValidationError(fnFunction: any, oListener: any): sap.ui.core.Core;

        /**
         * Detach event-handler <code>fnFunction</code> from the 'validationSuccess' event of
         * <code>sap.ui.core.Core</code>.<br/>The passed function and listener object must match the ones
         * previously used for event registration.
         * @param fnFunction The function to call, when the event occurs.
         * @param oListener Object on which the given function had to be called.
         * @returns <code>this</code> to allow method chaining
        */
        detachValidationSuccess(fnFunction: any, oListener: any): sap.ui.core.Core;


        /**
         * Fire event formatError to attached listeners.Expects following event parameters:<ul><li>'element' of
         * type <code>sap.ui.core.Element</code> </li><li>'property' of type <code>string</code>
         * </li><li>'type' of type <code>string</code> </li><li>'newValue' of type <code>object</code>
         * </li><li>'oldValue' of type <code>object</code> </li><li>'exception' of type <code>object</code>
         * </li></ul>
         * @param mArguments the arguments to pass along with the event.
         * @returns <code>this</code> to allow method chaining
        */
        fireFormatError(mArguments: any): sap.ui.core.Core;

        /**
         * Fire event parseError to attached listeners.Expects following event parameters:<ul><li>'element' of
         * type <code>sap.ui.core.Element</code> </li><li>'property' of type <code>string</code>
         * </li><li>'type' of type <code>string</code> </li><li>'newValue' of type <code>object</code>
         * </li><li>'oldValue' of type <code>object</code> </li><li>'exception' of type <code>object</code>
         * </li></ul>
         * @param mArguments the arguments to pass along with the event.
         * @returns <code>this</code> to allow method chaining
        */
        fireParseError(mArguments: any): sap.ui.core.Core;

        /**
         * Fire event validationError to attached listeners.Expects following event
         * parameters:<ul><li>'element' of type <code>sap.ui.core.Element</code> </li><li>'property' of type
         * <code>string</code> </li><li>'type' of type <code>string</code> </li><li>'newValue' of type
         * <code>object</code> </li><li>'oldValue' of type <code>object</code> </li><li>'exception' of type
         * <code>object</code> </li></ul>
         * @param mArguments the arguments to pass along with the event.
         * @returns <code>this</code> to allow method chaining
        */
        fireValidationError(mArguments: any): sap.ui.core.Core;

        /**
         * Fire event validationSuccess to attached listeners.Expects following event
         * parameters:<ul><li>'element' of type <code>sap.ui.core.Element</code> </li><li>'property' of type
         * <code>string</code> </li><li>'type' of type <code>string</code> </li><li>'newValue' of type
         * <code>object</code> </li><li>'oldValue' of type <code>object</code> </li></ul>
         * @param mArguments the arguments to pass along with the event.
         * @returns <code>this</code> to allow method chaining
        */
        fireValidationSuccess(mArguments: any): sap.ui.core.Core;

        /**
         * Returns the instance of the application (if exists).
         * @returns instance of the current application
        */
        getApplication(): any;

        /**
         * Returns the registered component for the given id, if any.
         * @param sId undefined
         * @returns the component for the given id
        */
        getComponent(sId: string): sap.ui.core.Component;

        /**
         * Returns the Configuration of the Core.
         * @returns the Configuration of the current Core.
        */
        getConfiguration(): sap.ui.core.Configuration;

        /**
         * Returns the registered element for the given ID, if any.
         * @param sId undefined
         * @returns the element for the given id
        */
        getControl(sId: string): sap.ui.core.Element;

        /**
         * Returns the Id of the control/element currently in focus.
         * @returns the Id of the control/element currently in focus.
        */
        getCurrentFocusedControlId(): string;

        /**
         * Returns the registered element for the given ID, if any.
         * @param sId undefined
         * @returns the element for the given id
        */
        getElementById(sId: string): sap.ui.core.Element;

        /**
         * Returns the event bus.
         * @since 1.8.0
         * @returns the event bus
        */
        getEventBus(): sap.ui.core.EventBus;

        /**
         * Retrieves a resource bundle for the given library and locale.If only one argument is given, it is
         * assumed to be the libraryName. The localethen falls back to the current {@link
         * sap.ui.core.Configuration.prototype.getLanguage session locale}.If no argument is given, the library
         * also falls back to a default: "sap.ui.core".
         * @param sLibraryName name of the library to retrieve the bundle for
         * @param sLocale locale to retrieve the resource bundle for
         * @returns the best matching resource bundle for the given parameters or undefined
        */
        getLibraryResourceBundle(sLibraryName: string, sLocale?: string): any;

        /**
         * Returns a map of library info objects for all currently loaded libraries,keyed by their names.The
         * structure of the library info objects matches the structure of the info objectthat the {@link
         * #initLibrary} method expects. Only property names documented with<code>initLibrary</code> should be
         * accessed, any additional properties might change ordisappear in future. When a property does not
         * exists, its default value (as documentedwith <code>initLibrary</code>) should be
         * assumed.<b>Note:</b> The returned info objects must not be modified. They might be a livingcopy of
         * the internal data (for efficiency reasons) and the framework is not preparedto handle modifications
         * to these objects.
         * @returns Map of library info objects keyed by the library names.
        */
        getLoadedLibraries(): any;

        /**
         * Returns the active <code>MessageManager</code> instance.
         * @since 1.33.0
        */
        getMessageManager(): sap.ui.core.message.MessageManager;

        /**
         * Returns a metadata object for class sap.ui.core.Core.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Get the model with the given model name.The name can be omitted to reference the default model or it
         * must be a non-empty string.Note: to be compatible with future versions of this API, applications
         * must not use the value <code>null</code>,the empty string <code>""</code> or the string literals
         * <code>"null"</code> or <code>"undefined"</code> as model name.
         * @param sName name of the model to be retrieved
         * @returns oModel
        */
        getModel(sName: string | any): sap.ui.model.Model;

        /**
        */
        getRenderManager(): void;

        /**
         * Returns the instance of the root component (if exists).
         * @returns instance of the current root component
        */
        getRootComponent(): sap.ui.core.Component;

        /**
         * Returns the static, hidden area DOM element belonging to this core instance.It can be used e.g. for
         * hiding elements like Popups, Shadow, Blocklayer etc.If it is not yet available, a DIV is created and
         * appended to the body.
         * @returns the static, hidden area DOM element belonging to this core instance.
        */
        getStaticAreaRef(): sap.ui.core.Element;

        /**
         * Returns the registered template for the given id, if any.
         * @param sId undefined
         * @returns the template for the given id
        */
        getTemplate(sId: string): sap.ui.core.Component;

        /**
         * Returns a UIArea if the given ID/Element belongs to one.
         * @param o a DOM Element or ID string of the UIArea
         * @returns a UIArea with a given id or dom ref.
        */
        getUIArea(o: string | sap.ui.core.Element): sap.ui.core.UIArea;

        /**
         * Returns <code>true</code> if there are any pending rendering tasks or whensuch rendering tasks are
         * currently being executed.
         * @returns true if there are pending (or executing) rendering tasks.
        */
        getUIDirty(): boolean;

        /**
         * Check if a Model is set to the core
         * @returns true or false
        */
        hasModel(): boolean;

        /**
         * Includes a library theme into the current page (if a variant is specified itwill include the variant
         * library theme)
         * @param sLibName the name of the UI library
         * @param sVariant the variant to include (optional)
         * @param sQuery to be used only by the Core
        */
        includeLibraryTheme(sLibName: string, sVariant?: string, sQuery?: string): void;

        /**
         * Provides the framework with information about a library.This method is intended to be called exactly
         * once while the main module of a library(its <code>library.js</code> module) is executing, typically
         * at its begin. The singleparameter <code>oLibInfo</code> is an info object that describes the content
         * of the library.When the <code>oLibInfo</code> has been processed, a normalized version of it will be
         * keptand will be returned as library information in later calls to {@link
         * #getLoadedLibraries}.Finally, <code>initLibrary</code> fires (the currently private) {@link
         * #event:LibraryChanged}event with operation 'add' for the newly loaded library.<h3>Side
         * Effects</h3>While analyzing the <code>oLibInfo</code>, the framework takes some additional
         * actions:<ul><li>If the info object contains a list of <code>interfaces</code>, they will be
         * registeredwith the {@link sap.ui.base.DataType} class to make them available as aggregation typesin
         * managed objects.</li><li>If the object contains a list of <code>controls</code> or
         * <code>elements</code>,{@link sap.ui.lazyRequire lazy stubs} will be created for their constructor as
         * well as fortheir static <code>extend</code> and <code>getMetadata</code> methods.<br><b>Note:</b>
         * Future versions might abandon the concept of lazy stubs as it requires synchronousXMLHttpRequests
         * which have been deprecated (see {@link http://xhr.spec.whatwg.org}). To be on thesafe side,
         * productive applications should always require any modules that they directly depend on.</li><li>With
         * the <code>noLibraryCSS</code> property, the library can be marked as 'theming-free'.Otherwise, the
         * framework will add a &lt;link&gt; tag to the page's head, pointing to the library'stheme-specific
         * stylesheet. The creation of such a &lt;link&gt; tag can be suppressed with the{@link
         * sap.ui.core.Configuration global configuration option} <code>preloadLibCss</code>.It can contain a
         * list of library names for which no stylesheet should be included.This is e.g. useful when an
         * application merges the CSS for multiple libraries and alreadyloaded the resulting
         * stylesheet.</li><li>If a list of library <code>dependencies</code> is specified in the info object,
         * thoselibraries will be loaded synchronously by <code>initLibrary</code>.<br><b>Note:</b>
         * Dependencies between libraries don't have to be modeled as AMD dependencies.Only when enums or types
         * from an additional library are used in the coding of the<code>library.js</code> module, the library
         * should be additionally listed in the AMD dependencies.</li></ul>Last but not least, higher layer
         * frameworks might want to include their own metadata for libraries.The property
         * <code>extensions</code> might contain such additional metadata. Its structure is not definedby the
         * framework, but it is strongly suggested that each extension only occupies a single propertyin the
         * <code>extensions</code> object and that the name of that property contains some namespaceinformation
         * (e.g. library name that introduces the feature) to avoid conflicts with other extensions.The
         * framework won't touch the content of <code>extensions</code> but will make it availablein the
         * library info objects returned by {@link #getLoadedLibraries}.<h3>Relationship to Descriptor for
         * Libraries (manifest.json)</h3>The information contained in <code>oLibInfo</code> is partially
         * redundant to the content of the descriptorfor the same library (its <code>manifest.json</code>
         * file). Future versions of UI5 might ignore the informationprovided in <code>oLibInfo</code> and
         * might evaluate the descriptor file instead. Library developers thereforeshould keep the information
         * in both files in sync.When the <code>manifest.json</code> is generated from the
         * <code>.library</code> file (which is the defaultfor UI5 libraries built with Maven), then the
         * content of the <code>.library</code> and <code>library.js</code>files must be kept in sync.
         * @param oLibInfo Info object for the library
        */
        initLibrary(oLibInfo: any): void;

        /**
         * Returns true if the Core has already been initialized. This means that instancesof RenderManager
         * etc. do already exist and the init event has already been fired(and will not be fired again).
         * @returns whether the Core has already been initialized
        */
        isInitialized(): boolean;

        /**
         * Returns the locked state of the <code>sap.ui.core.Core</code>
         * @returns locked state
        */
        isLocked(): boolean;

        /**
         * Check if the script is running on mobile
         * @returns true or false
        */
        isMobile(): boolean;

        /**
         * Used to find out whether a certain DOM element is the static area
         * @param oDomRef undefined
         * @returns whether the given DomRef is the StaticAreaRef
        */
        isStaticAreaRef(oDomRef: any): boolean;

        /**
         * Returns true, if the styles of the current theme are already applied, false otherwise.This function
         * must not be used before the init event of the Core.If the styles are not yet applied an theme
         * changed event will follow when the styles will be applied.
         * @returns whether the styles of the current theme are already applied
        */
        isThemeApplied(): boolean;

        /**
         * Loads a set of libraries, preferably asynchronously.The module loading is still synchronous, so if a
         * library loads additional modules besidesits library.js file, those modules might be loaded
         * synchronously by the library.jsThe async loading is only supported by the means of the
         * library-preload.json files, so if alibrary doesn't provide a preload or when the preload is
         * deactivated (configuration, debug mode)then this API falls back to synchronous loading. However, the
         * contract (Promise) remains validand a Promise will be returned if async is specified - even when the
         * real loadingis done synchronously.
         * @param aLibraries set of libraries that should be loaded
         * @param mOptions configuration options
         * @returns returns a Promise in async mode, otherwise <code>undefined</code>
        */
        loadLibraries(aLibraries: string[], mOptions?: any): JQueryPromise<any> | any;

        /**
         * Synchronously loads the given library and makes it available to the application.Loads the *.library
         * module, which contains all preload modules (enums, types, content of a shared.jsif it exists). The
         * library module will call initLibrary with additional metadata for the library.As a result, consuming
         * applications can instantiate any control or element from that librarywithout having to write import
         * statements for the controls or for the enums.When the optional parameter <code>sUrl</code> is given,
         * then all request for resources of thelibrary will be redirected to the given Url. This is
         * convenience for a call to<pre>  jQuery.sap.registerModulePath(sLibrary, sUrl);</pre>When the given
         * library has been loaded already, no further action will be taken.Especially, a given Url will not be
         * honored!Note: this method does not participate in the supported preload of libraries.
         * @param sLibrary name of the library to import
         * @param sUrl URL to load the library from
        */
        loadLibrary(sLibrary: string, sUrl?: string): void;

        /**
         * Locks the Core. No browser events are dispatched to the controls.Lock should be called before and
         * after the dom is modified for rendering, roundtrips...Exceptions might be the case for asynchronous
         * UI behavior
        */
        lock(): void;

        /**
         * Registers a Plugin to the <code>sap.ui.core.Core</code>, which lifecyclewill be managed (start and
         * stop).<br/>Plugin object need to implement two methods:<ul>  <li><code>startPlugin(oCore)</code>:
         * will be invoked, when the Plugin      should start (as parameter the reference to the Core will be
         * provided</li>  <li><code>stopPlugin()</code>: will be invoked, when the Plugin should stop</li></ul>
         * @param oPlugin reference to a Plugin object
        */
        registerPlugin(oPlugin: any): void;

        /**
         * Sets or unsets a model for the given model name.The <code>sName</code> must either be
         * <code>undefined</code> (or omitted) or a non-empty string.When the name is omitted, the default
         * model is set/unset.When <code>oModel</code> is <code>null</code> or <code>undefined</code>, a
         * previously set modelwith that name is removed from the Core.Any change (new model, removed model) is
         * propagated to all existing UIAreas and their descendantsas long as a descendant doesn't have its own
         * model set for the given name.Note: to be compatible with future versions of this API, applications
         * must not use the value <code>null</code>,the empty string <code>""</code> or the string literals
         * <code>"null"</code> or <code>"undefined"</code> as model name.
         * @param oModel the model to be set or <code>null</code> or <code>undefined</code>
         * @param sName the name of the model or <code>undefined</code>
         * @returns <code>this</code> to allow method chaining
        */
        setModel(oModel: sap.ui.model.Model, sName?: string): sap.ui.core.Core;

        /**
         * Implicitly creates a new <code>UIArea</code> (or reuses an exiting one) for the given DOM reference
         * andadds the given control reference to the UIAreas content (existing content will be removed).
         * @param oDomRef a DOM Element or Id (string) of the UIArea
         * @param oControl the Control that should be the added to the <code>UIArea</code>.
        */
        setRoot(oDomRef: string | sap.ui.core.Element, oControl: sap.ui.base.Interface | sap.ui.core.Control): void;

        /**
         * Defines the root directory from below which UI5 should load the theme with the given name.Optionally
         * allows restricting the setting to parts of a theme covering specific control
         * libraries.Example:<code>  core.setThemeRoot("my_theme", "http://mythemeserver.com/allThemes"); 
         * core.applyTheme("my_theme");</code>will cause the following file to be
         * loaded:<code>http://mythemeserver.com/allThemes/sap/ui/core/themes/my_theme/library.css</code>(and
         * the respective files for all used control libraries, like
         * <code>http://mythemeserver.com/allThemes/sap/ui/commons/themes/my_theme/library.css</code>if the
         * sap.ui.commons library is used)If parts of the theme are at different locations (e.g. because you
         * provide a standard theme like "sap_goldreflection" for a custom control library andthis self-made
         * part of the standard theme is at a different location than the UI5 resources), you can also specify
         * for which control libraries the settingshould be used, by giving an array with the names of the
         * respective control libraries as second parameter:<code>core.setThemeRoot("sap_goldreflection",
         * ["my.own.library"], "http://mythemeserver.com/allThemes");</code>This will cause the Gold Reflection
         * theme to be loaded normally from the UI5 location, but the part for styling the "my.own.library"
         * controls will be loaded
         * ode>http://mythemeserver.com/allThemes/my/own/library/themes/sap_goldreflection/library.css</code>If
         * the custom theme should be loaded initially (via bootstrap attribute), the "themeRoots" property of
         * the window["sap-ui-config"] object must be used insteadof Core.setThemeRoot(...) in order to
         * configure the theme location early enough.
         * @since 1.10
         * @param sThemeName the name of the theme for which to configure the location
         * @param aLibraryNames the optional library names to which the configuration should be restricted
         * @param sThemeBaseUrl the base URL below which the CSS file(s) will be loaded from
         * @returns the Core, to allow method chaining
        */
        setThemeRoot(sThemeName: string, aLibraryNames: string[], sThemeBaseUrl: string): sap.ui.core.Core;

        /**
         * Unlocks the Core.Browser events are dispatched to the controls again after this method is called.
        */
        unlock(): void;

        /**
         * Unregisters a Plugin out of the <code>sap.ui.core.Core</code>
         * @param oPlugin reference to a Plugin object
        */
        unregisterPlugin(oPlugin: any): void;
      }
      /**
       * Represents a title element that can be used for aggregation with other controls
       * @resource sap/ui/core/Title.js
      */
      export class Title extends sap.ui.core.Element {


        /**
         * Constructor for a new Title.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);




        /**
         * Gets current value of property <code>emphasized</code>.If set the title is displayed emphasized.This
         * feature is nor supported by all controls using the Title.control.Default value is
         * <code>false</code>.
         * @returns Value of property <code>emphasized</code>
        */
        getEmphasized(): boolean;

        /**
         * Gets current value of property <code>icon</code>.Defines the URL for icon display
         * @returns Value of property <code>icon</code>
        */
        getIcon(): any;

        /**
         * Gets current value of property <code>level</code>.Defines the level of the title. If set to auto the
         * level of the title is chosen by the control rendering the title.Currently not all controls using the
         * Title.control supporting this property.Default value is <code>Auto</code>.
         * @returns Value of property <code>level</code>
        */
        getLevel(): sap.ui.core.TitleLevel;

        /**
         * Returns a metadata object for class sap.ui.core.Title.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>text</code>.Defines the title text
         * @returns Value of property <code>text</code>
        */
        getText(): string;

        /**
         * Sets a new value for property <code>emphasized</code>.If set the title is displayed emphasized.This
         * feature is nor supported by all controls using the Title.control.When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>false</code>.
         * @param bEmphasized New value for property <code>emphasized</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setEmphasized(bEmphasized: boolean): sap.ui.core.Title;

        /**
         * Sets a new value for property <code>icon</code>.Defines the URL for icon displayWhen called with a
         * value of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.
         * @param sIcon New value for property <code>icon</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setIcon(sIcon: any): sap.ui.core.Title;

        /**
         * Sets a new value for property <code>level</code>.Defines the level of the title. If set to auto the
         * level of the title is chosen by the control rendering the title.Currently not all controls using the
         * Title.control supporting this property.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.Default value is
         * <code>Auto</code>.
         * @param sLevel New value for property <code>level</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setLevel(sLevel: sap.ui.core.TitleLevel): sap.ui.core.Title;

        /**
         * Sets a new value for property <code>text</code>.Defines the title textWhen called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
         * @param sText New value for property <code>text</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setText(sText: string): sap.ui.core.Title;
      }
      /**
       * Popup Class is a helper class for controls that want themselves orparts of themselves or even other
       * aggregated or composed controlsor plain HTML content to popup on the screen like menues, dialogs,
       * drop down boxes.It allows the controls to be aligned to other dom elementsusing the {@link
       * sap.ui.core.Popup.Dock} method. With it you can define wherethe popup should be docked. One can dock
       * the popup to the top bottom left or right sideof a dom ref.In the case that the popup has no space
       * to show itself in the view portof the current window it tries to open itself tothe inverted
       * direction.<strong>Since 1.12.3</strong> it is possible to add further DOM-element-ids that can get
       * the focuswhen 'autoclose' is enabled. E.g. the RichTextEditor with running TinyMCE uses this method
       * tobe able to focus the Popups of the TinyMCE if the RichTextEditor runs within a Popup/Dialog etc.
       * To provide an additional DOM-element that can get the focus the following should be done:	// create
       * an object with the corresponding DOM-id	var oObject = {		id :
       * "this_is_the_most_valuable_id_of_the_DOM_element"	};	// add the event prefix for adding an element
       * to the ID of the corresponding Popup	var sEventId = "sap.ui.core.Popup.addFocusableContent-" +
       * oPopup.getId();	// fire the event with the created event-id and the object with the DOM-id
       * sap.ui.getCore().getEventBus().publish("sap.ui", sEventId, oObject);
       * @resource sap/ui/core/Popup.js
      */
      export class Popup extends sap.ui.base.ManagedObject {


        /**
         * Creates an instance of <code>sap.ui.core.Popup</code> that can be used to open controls as a
         * Popup,visually appearing in front of other controls.Accepts an object literal <code>mSettings</code>
         * that defines initialproperty values, aggregated and associated objects as well as event handlers.See
         * {@link sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the
         * settings object.
         * @param oContent the content to render in the popup. In case of sap.ui.core.Element or DOMNode, the
         * content must be present in the page (i.e. rendered). In case of sap.ui.core.Control, the Popup
         * ensures rendering before opening.
         * @param bModal whether the popup should be opened in a modal way (i.e. with blocking background).
         * Setting this to "true" effectively blocks all attempts to focus content outside the modal popup. A
         * modal popup also automatically sets the focus back to whatever was focused when the popup opened.
         * @param bShadow whether the popup should be have a visual shadow underneath (shadow appearance
         * depends on active theme and browser support)
         * @param bAutoClose whether the popup should automatically close when the focus moves out of the popup
        */
        constructor(oContent: sap.ui.core.Control | sap.ui.core.Element | any, bModal?: boolean, bShadow?: boolean, bAutoClose?: boolean);



        /**
         * Attaches event handler <code>fnFunction</code> to the <code>closed</code> event of this
         * <code>sap.ui.core.Popup</code>.When called, the context of the event handler (its <code>this</code>)
         * will be bound to <code>oListener</code> if specified, otherwise it will be bound to this
         * <code>sap.ui.core.Popup</code> itself.
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.core.Popup</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachClosed(oData: any, fnFunction: any, oListener?: any): sap.ui.core.Popup;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>opened</code> event of this
         * <code>sap.ui.core.Popup</code>.When called, the context of the event handler (its <code>this</code>)
         * will be bound to <code>oListener</code> if specified, otherwise it will be bound to this
         * <code>sap.ui.core.Popup</code> itself.
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.core.Popup</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachOpened(oData: any, fnFunction: any, oListener?: any): sap.ui.core.Popup;

        /**
         * Closes the popup.If the Popup is already closed or in the process of closing, calling this method
         * does nothing.If the Popup is in the process of being opened and closed with a duration of 0, calling
         * this method does nothing.If the Popup is in the process of being opened and closed with an animation
         * duration, the animation will be chained, but this functionality is dangerous,may lead to
         * inconsistent behavior and is thus not recommended and may even be removed.
         * @param iDuration animation duration in milliseconds; default is the jQuery preset "fast".  For
         * iDuration == 0 the closing happens synchronously without animation.
        */
        close(iDuration: number): void;

        /**
         * Closes and destroys this instance of Popup.Does not destroy the hosted content.
        */
        destroy(bSuppressInvalidate: boolean): void;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>closed</code> event of this
         * <code>sap.ui.core.Popup</code>.The passed function and listener object must match the ones used for
         * event registration.
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachClosed(fnFunction: any, oListener: any): sap.ui.core.Popup;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>opened</code> event of this
         * <code>sap.ui.core.Popup</code>.The passed function and listener object must match the ones used for
         * event registration.
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachOpened(fnFunction: any, oListener: any): sap.ui.core.Popup;

        /**
         * When the Popup is being destroyed all corresponding references should bedeleted as well to prevent
         * any memory leaks.
        */
        exit(): void;


        /**
         * Fires event <code>closed</code> to attached listeners.
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireClosed(mArguments: any): sap.ui.core.Popup;

        /**
         * Fires event <code>opened</code> to attached listeners.
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireOpened(mArguments: any): sap.ui.core.Popup;

        /**
         * Determines whether the pop-up should auto closes or not.
         * @since 1.16
        */
        getAutoClose(): boolean;

        /**
         * Returns this Popup's content.
         * @returns the content that has been set previously (if any)
        */
        getContent(): sap.ui.core.Control | any;

        /**
         * This returns true/false if the default followOf method should be used. If a separate
         * followOf-handler was previously addedthe correspodning function is returned.
         * @since 1.13.0
         * @returns if a function was set it is returned otherwise a boolean value whether the follow of is
         * activated
        */
        getFollowOf(): boolean | any;

        /**
         * Returns the last z-index that has been handed out. does not increase the internal z-index counter.
        */
        getLastZIndex(): Number;

        /**
         * Returns a metadata object for class sap.ui.core.Popup.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Returns the value if a Popup is of modal type
        */
        getModal(): void;

        /**
         * Returns the next available z-index on top of the existing/previous popups. Each call increases the
         * internal z-index counter and the returned z-index.
         * @returns the next z-index on top of the Popup stack
        */
        getNextZIndex(): Number;

        /**
         * Returns whether the Popup is currently open, closed, or transitioning between these states.
         * @returns whether the Popup is opened
        */
        getOpenState(): sap.ui.core.OpenState;

        /**
         * Returns whether the Popup is currently open (this includes opening andclosing animations).
         * @returns whether the Popup is opened (or currently being                           opened or closed)
        */
        isOpen(): boolean;

        /**
         * Opens the popup's content at the position either specified here or beforehand via {@link
         * #setPosition}.Content must be capable of being positioned via "position:absolute;"All parameters are
         * optional (open() may be called without any parameters). iDuration may just be omitted, but if any of
         * "at", "of", "offset", "collision" is given, also the preceding positioning parameters ("my",
         * at",...) must be given.If the Popup's OpenState is different from "CLOSED" (i.e. if the Popup is
         * already open, opening or closing), the call is ignored.
         * @param iDuration animation duration in milliseconds; default is the jQuery preset "fast". For
         * iDuration == 0 the opening happens synchronously without animation.
         * @param my the popup content's reference position for docking
         * @param at the "of" element's reference point for docking to
         * @param of specifies the reference element to which the given content should dock to
         * @param offset the offset relative to the docking point, specified as a string with space-separated
         * pixel values (e.g. "0 10" to move the popup 10 pixels to the right). If the docking of both "my" and
         * "at" are both RTL-sensitive ("begin" or "end"), this offset is automatically mirrored in the RTL
         * case as well.
         * @param collision defines how the position of an element should be adjusted in case it overflows the
         * window in some direction.
         * @param followOf defines whether the popup should follow the dock reference when the reference
         * changes its position.
        */
        open(iDuration: number, my?: typeof sap.ui.core.Popup.Dock, at?: typeof sap.ui.core.Popup.Dock, of?: string | sap.ui.core.Element | any | typeof jQuery | any, offset?: string, collision?: string, followOf?: boolean): void;

        /**
         * Sets the animation functions to use for opening and closing the Popup. Any null value will be
         * ignored and not change the respective animation function.When called, the animation functions
         * receive three parameters:- the jQuery object wrapping the DomRef of the popup- the requested
         * animation duration- a function that MUST be called once the animation has completed
         * @param fnOpen undefined
         * @param fnClose undefined
         * @returns <code>this</code> to allow method chaining
        */
        setAnimations(fnOpen: any, fnClose: any): sap.ui.core.Popup;

        /**
         * Used to specify whether the Popup should close as soon as- for non-touch environment: the focus
         * leaves- for touch environment: user clicks the area which is outside the popup itself, the dom
         * elemnt which popup aligns to (except document), and one of the autoCloseAreas set by calling
         * setAutoCloseAreas.
         * @param bAutoClose whether the Popup should close as soon as the focus leaves
         * @returns <code>this</code> to allow method chaining
        */
        setAutoClose(bAutoClose: boolean): sap.ui.core.Popup;

        /**
         * Sets the additional areas in the page that are considered part of the Popup when autoclose is
         * enabled.- non-touch environment: if the focus leaves the Popup but immediately enters one of these
         * areas, the Popup does NOT close.- touch environment: if user clicks one of these areas, the Popup
         * does NOT close.
         * @param aAutoCloseAreas an array containing DOM elements considered part of the Popup; a value of
         * null removes all previous areas
         * @returns <code>this</code> to allow method chaining
        */
        setAutoCloseAreas(aAutoCloseAreas: any): sap.ui.core.Popup;

        /**
         * Sets the content this instance of the Popup should render.Content must be capable of being
         * positioned via position:absolute;
         * @param oContent undefined
         * @returns <code>this</code> to allow method chaining
        */
        setContent(oContent: sap.ui.core.Control | any): sap.ui.core.Popup;

        /**
         * Sets the durations for opening and closing animations.Null values and values < 0 are ignored.A
         * duration of 0 means no animation.Default value is "fast" which is the jQuery constant for "200 ms".
         * @param iOpenDuration in milliseconds
         * @param iCloseDuration in milliseconds
         * @returns <code>this</code> to allow method chaining
        */
        setDurations(iOpenDuration: number, iCloseDuration: number): sap.ui.core.Popup;

        /**
         * This enabled/disables the Popup to follow its opening reference. If the Popup is open and a followOf
         * shouldbe set the corresponding listener will be attached.
         * @since 1.13.0
         * @param followOf a boolean value enabled/disables the default followOf-Handler. Or an individual
         * handler can be given.null deletes all followOf settings.
        */
        setFollowOf(followOf: boolean | any | any): void;

        /**
         * Sets the ID of the element that should be focused once the popup opens.If the given ID is the ID of
         * an existing Control, this Control's focusDomRef will be focused instead, which may be an HTML
         * element with a different ID (usually a sub-element inside the Control).If no existing element ID is
         * supplied and the Popup is modal or auto-close, the Popup will instead focus the first focusable
         * element.
         * @param sId the ID of the DOM element to focus
        */
        setInitialFocusId(sId: string): void;

        /**
         * Set an initial z-index that should be used by all Popup so all Popups start at leastwith the set
         * z-index.If the given z-index is lower than any current available z-index the highest z-index will be
         * used.
         * @since 1.30.0
         * @param iInitialZIndex is the initial z-index
        */
        setInitialZIndex(iInitialZIndex: Number): void;

        /**
         * Used to specify whether the Popup should be modal. A modal popup will put some fading "block layer"
         * over the background andprevent attempts to put the focus outside/below the popup.Setting this while
         * the popup is open will change "block layer" immediately.
         * @param bModal whether the Popup is of modal type
         * @param sModalCSSClass a CSS class (or space-separated list of classes) that should be added to the
         * block layer
         * @returns <code>this</code> to allow method chaining
        */
        setModal(bModal: boolean, sModalCSSClass?: string): sap.ui.core.Popup;

        /**
         * Sets the position of the Popup (if you refer to a Control as anchor then do notuse the DOMRef of the
         * control which might change after re-renderings).Optional parameters can only be omitted when all
         * subsequent parameters are omitted as well.
         * @param my specifies which point of the given Content should be aligned
         * @param at specifies the point of the reference element to which the given Content should be aligned
         * @param of specifies the reference element to which the given content should be aligned as specified
         * in the other parameters
         * @param offset the offset relative to the docking point, specified as a string with space-separated
         * pixel values (e.g. "0 10" to move the popup 10 pixels to the right). If the docking of both "my" and
         * "at" are both RTL-sensitive ("begin" or "end"), this offset is automatically mirrored in the RTL
         * case as well.
         * @param collision defines how the position of an element should be adjusted in case it overflows the
         * window in some direction. The valid values that refer to jQuery-UI's position parameters are "flip",
         * "fit" and "none".
         * @returns <code>this</code> to allow method chaining
        */
        setPosition(my: typeof sap.ui.core.Popup.Dock, at: typeof sap.ui.core.Popup.Dock | any, of?: string | sap.ui.core.Element | any | typeof jQuery | any, offset?: string, collision?: string): sap.ui.core.Popup;

        /**
         * Determines whether the Popup should have a shadow (in supporting browsers).This also affects a
         * currently open popup.
         * @param bShowShadow whether to show a shadow
         * @returns <code>this</code> to allow method chaining
        */
        setShadow(bShowShadow: boolean): sap.ui.core.Popup;
      }
      /**
       * Locale represents a locale setting, consisting of a language, script, region, variants, extensions
       * and private use section
       * @resource sap/ui/core/Locale.js
      */
      export class Locale extends sap.ui.base.Object {


        /**
         * Creates an instance of the Locale.
         * @param sLocaleId the locale identifier, in format en-US or en_US.
        */
        constructor(sLocaleId: string);




        /**
         * Get the locale extension as a single string or null.The extension always consists of a singleton
         * character (not 'x'),a dash '-' and one or more extension token, each separatedagain with a dash.Use
         * {@link #getExtensions} to get the individual extension tokens as an array.
         * @returns the extension
        */
        getExtension(): string;

        /**
         * Get the locale extensions as an array of tokens.The leading singleton and the separating dashes are
         * not part of the result.If there is no extensions section in the locale tag, an empty array is
         * returned.
         * @returns the individual extension sections
        */
        getExtensionSubtags(): string[];

        /**
         * Get the locale language.Note that the case might differ from the original script tag(Lower case is
         * enforced as recommended by BCP47/ISO639).
         * @returns the language code
        */
        getLanguage(): string;

        /**
         * Returns a metadata object for class sap.ui.core.Locale.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Get the locale private use section or null.
         * @returns the private use section
        */
        getPrivateUse(): string;

        /**
         * Get the locale private use section
         * @returns the private use section
        */
        getPrivateUseSubtags(): string;

        /**
         * Get the locale region or null if none was specified.Note that the case might differ from the
         * original script tag(Upper case is enforced as recommended by BCP47/ISO3166-1).
         * @returns the ISO3166-1 region code (2-letter or 3-digits)
        */
        getRegion(): string;

        /**
         * Best guess to get a proper SAP Logon Language for this locale.Conversions taken into
         * account:<ul><li>use the language part only</li><li>convert old ISO639 codes to newer ones (e.g. 'iw'
         * to 'he')</li><li>for Chinese, map 'Traditional Chinese' to SAP proprietary code 'zf'</li><li>map
         * private extensions x-sap1q and x-sap2q to SAP pseudo languages '1Q' and '2Q'</li><li>remove ext.
         * language sub tags</li><li>convert to uppercase</li></ul>Note that the conversion also returns a
         * result for languages that are notsupported by the default set of SAP languages. This method has no
         * knowledgeabout the concrete languages of any given backend system.
         * @since 1.17.0
         * @returns a language code that should
        */
        getSAPLogonLanguage(): string;

        /**
         * Get the locale script or null if none was specified.Note that the case might differ from the
         * original language tag(Upper case first letter and lower case reminder enforced asrecommended by
         * BCP47/ISO15924)
         * @returns the script code or null
        */
        getScript(): string;

        /**
         * Get the locale variants as a single string or null.Multiple variants are separated by a dash '-'.
         * @returns the variant or null
        */
        getVariant(): string;

        /**
         * Get the locale variants as an array of individual variants.The separating dashes are not part of the
         * result.If there is no variant section in the locale tag, an empty array is returned.
         * @returns the individual variant sections
        */
        getVariantSubtags(): string[];
      }
      /**
       * An area in a page that hosts a tree of UI elements.Provides means for event-handling, rerendering,
       * etc.Special aggregation "dependents" is connected to the lifecycle management and databinding,but
       * not rendered automatically and can be used for popups or other dependent controls. This
       * allowsdefinition of popup controls in declarative views and enables propagation of model and
       * contextinformation to them.
       * @resource sap/ui/core/UIArea.js
      */
      export class UIArea extends sap.ui.base.ManagedObject {


        /**
         * Accepts an object literal <code>mSettings</code> that defines initialproperty values, aggregated and
         * associated objects as well as event handlers.See {@link sap.ui.base.ManagedObject#constructor} for a
         * general description of the syntax of the settings object.
         * @param oCore internal API of the <core>Core</code> that manages this UIArea
         * @param oRootNode reference to the Dom Node that should be 'hosting' the UI Area.
        */
        constructor(oCore: sap.ui.core.Core, oRootNode?: any);



        /**
         * Adds some content to the aggregation <code>content</code>.
         * @param oContent the content to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addContent(oContent: sap.ui.core.Control): sap.ui.core.UIArea;

        /**
         * Adds some dependent to the aggregation <code>dependents</code>.
         * @param oDependent the dependent to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addDependent(oDependent: sap.ui.core.Control): sap.ui.core.UIArea;

        /**
         * Destroys all the content in the aggregation <code>content</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyContent(): sap.ui.core.UIArea;

        /**
         * Destroys all the dependents in the aggregation <code>dependents</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyDependents(): sap.ui.core.UIArea;


        /**
         * Provide getBindingContext, as UIArea can be parent of an element.
        */
        getBindingContext(sModelName: string): sap.ui.model.Context;

        /**
         * Gets content of aggregation <code>content</code>.Content that is displayed in the UIArea.
        */
        getContent(): sap.ui.core.Control[];

        /**
         * Gets content of aggregation <code>dependents</code>.Dependent objects whose lifecycle is bound to
         * the UIarea but which are not automatically rendered by the UIArea.
        */
        getDependents(): sap.ui.core.Control[];

        /**
         * Returns the Core's event provider as new eventing parent to enable control event bubbling to the
         * core to ensure compatibility with the core validation events.
         * @returns the parent event provider
        */
        getEventingParent(): sap.ui.base.EventProvider;

        /**
         * Returns this <code>UIArea</code>'s id (as determined from provided RootNode).
         * @returns id of this UIArea
        */
        getId(): string | any;

        /**
         * Returns a metadata object for class sap.ui.core.UIArea.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Returns the content control of this <code>UIArea</code> at the specified index.If no index is given
         * the first content control is returned.
         * @param idx index of the control in the content of this <code>UIArea</code>
         * @returns the content control of this <code>UIArea</code> at the specified index.
        */
        getRootControl(idx: number): sap.ui.core.Control;

        /**
         * Returns the Root Node hosting this instance of <code>UIArea</code>.
         * @returns the Root Node hosting this instance of <code>UIArea</code>.
        */
        getRootNode(): sap.ui.core.Element;

        /**
         * Returns this UI area. Needed to stop recursive calls from an element to its parent.
         * @returns this
        */
        getUIArea(): sap.ui.core.UIArea;

        /**
         * Checks for the provided <code>sap.ui.core.Control</code> in the aggregation <code>content</code>.and
         * returns its index if found or -1 otherwise.
         * @param oContent The content whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfContent(oContent: sap.ui.core.Control): number;

        /**
         * Checks for the provided <code>sap.ui.core.Control</code> in the aggregation
         * <code>dependents</code>.and returns its index if found or -1 otherwise.
         * @param oDependent The dependent whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfDependent(oDependent: sap.ui.core.Control): number;

        /**
         * Inserts a content into the aggregation <code>content</code>.
         * @param oContent the content to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the content should be inserted at; for             a
         * negative value of <code>iIndex</code>, the content is inserted at position 0; for a value           
         *  greater than the current size of the aggregation, the content is inserted at             the last
         * position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertContent(oContent: sap.ui.core.Control, iIndex: number): sap.ui.core.UIArea;

        /**
         * Inserts a dependent into the aggregation <code>dependents</code>.
         * @param oDependent the dependent to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the dependent should be inserted at; for             a
         * negative value of <code>iIndex</code>, the dependent is inserted at position 0; for a value         
         *    greater than the current size of the aggregation, the dependent is inserted at             the
         * last position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertDependent(oDependent: sap.ui.core.Control, iIndex: number): sap.ui.core.UIArea;

        /**
         * Will be used as end-point for invalidate-bubbling from controls up their hierarchy.<br/> Triggers
         * re-rendering ofthe UIAreas content.
        */
        invalidate(oOrigin?: any): void;

        /**
         * Checks whether the control is still valid (is in the DOM)
         * @returns True if the control is still in the active DOM
        */
        isActive(): boolean;

        /**
         * Returns whether rerendering is currently suppressed on this UIArea
        */
        isInvalidateSuppressed(): void;

        /**
         * Returns the locked state of the <code>sap.ui.core.UIArea</code>
         * @returns locked state
        */
        isLocked(): boolean;

        /**
         * Locks this instance of UIArea.Rerendering and eventing will not be active as long as no{@link
         * #unlock} is called.
        */
        lock(): void;

        /**
         * Removes all the controls from the aggregation <code>content</code>.Additionally, it unregisters them
         * from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllContent(): sap.ui.core.Control[];

        /**
         * Removes all the controls from the aggregation <code>dependents</code>.Additionally, it unregisters
         * them from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllDependents(): sap.ui.core.Control[];

        /**
         * Removes a content from the aggregation <code>content</code>.
         * @param vContent The content to remove or its index or id
         * @returns The removed content or <code>null</code>
        */
        removeContent(vContent: number | string | sap.ui.core.Control): sap.ui.core.Control;

        /**
         * Removes a dependent from the aggregation <code>dependents</code>.
         * @param vDependent The dependent to remove or its index or id
         * @returns The removed dependent or <code>null</code>
        */
        removeDependent(vDependent: number | string | sap.ui.core.Control): sap.ui.core.Control;

        /**
         * Sets the root control to be displayed in this UIArea.First, all old content controls (if any) will
         * be detached from this UIArea (e.g. their parentrelationship to this UIArea will be cut off). Then
         * the parent relationship for the newcontent control (if not empty) will be set to this UIArea and
         * finally, the UIArea willbe marked for re-rendering.The real re-rendering happens whenever the
         * re-rendering is called. Either implicitlyat the end of any control event or by calling
         * sap.ui.getCore().applyChanges().
         * @param oRootControl the Control that should be the Root for this <code>UIArea</code>.
        */
        setRootControl(oRootControl: sap.ui.base.Interface | sap.ui.core.Control): void;

        /**
         * Allows setting the Root Node hosting this instance of <code>UIArea</code>.<br/> The Dom Ref must
         * have an Id thatwill be used as Id for this instance of <code>UIArea</code>.
         * @param oRootNode the hosting Dom Ref for this instance of <code>UIArea</code>.
        */
        setRootNode(oRootNode: any): void;

        /**
         * Un-Locks this instance of UIArea.Rerendering and eventing will now be enabled again.
        */
        unlock(): void;
      }
      /**
       * Base Class for Elements.
       * @resource sap/ui/core/Element.js
      */
      export class Element extends sap.ui.base.ManagedObject {


        /**
         * Constructs and initializes an UI Element with the given <code>sId</code> and settings.If the
         * optional <code>mSettings</code> are given, they must be a JSON-like object (object literal)that
         * defines values for properties, aggregations, associations or events keyed by their name.<b>Valid
         * Names:</b>The property (key) names supported in the object literal are exactly the (case
         * sensitive)names documented in the JSDoc for the properties, aggregations, associations and eventsof
         * the control and its base classes. Note that for  0..n aggregations and associations thisusually is
         * the plural name, whereas it is the singular name in case of 0..1 relations.If a key name is
         * ambiguous for a specific control class (e.g. a property has the samename as an event), then this
         * method prefers property, aggregation, association andevent in that order. To resolve such
         * ambiguities, the keys can be prefixed with<code>aggregation:</code>, <code>association:</code> or
         * <code>event:</code>.In that case the keys must be quoted due to the ':'.Each subclass should
         * document the set of supported names in its constructor documentation.<b>Valid Values:</b><ul><li>for
         * normal properties, the value has to be of the correct simple type (no type conversion occurs)<li>for
         * 0..1 aggregations, the value has to be an instance of the aggregated control or element type<li>for
         * 0..n aggregations, the value has to be an array of instances of the aggregated type<li>for 0..1
         * associations, an instance of the associated type or an id (string) is accepted<li>0..n associations
         * are not supported yet<li>for events either a function (event handler) is accepted or an array of
         * length 2    where the first element is a function and the 2nd element is an object to invoke the
         * method on.</ul>Special aggregation "dependents" is connected to the lifecycle management and
         * databinding,but not rendered automatically and can be used for popups or other dependent controls.
         * This allowsdefinition of popup controls in declarative views and enables propagation of model and
         * contextinformation to them.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId id for the new control; generated automatically if no non-empty id is given     Note:
         * this can be omitted, no matter whether <code>mSettings</code> will be given or not!
         * @param mSettings optional map/JSON-object with initial property values, aggregated objects etc. for
         * the new element
        */
        constructor(sId: string, mSettings?: any);


        /**
         * Constructs and initializes an UI Element with the given <code>sId</code> and settings.If the
         * optional <code>mSettings</code> are given, they must be a JSON-like object (object literal)that
         * defines values for properties, aggregations, associations or events keyed by their name.<b>Valid
         * Names:</b>The property (key) names supported in the object literal are exactly the (case
         * sensitive)names documented in the JSDoc for the properties, aggregations, associations and eventsof
         * the control and its base classes. Note that for  0..n aggregations and associations thisusually is
         * the plural name, whereas it is the singular name in case of 0..1 relations.If a key name is
         * ambiguous for a specific control class (e.g. a property has the samename as an event), then this
         * method prefers property, aggregation, association andevent in that order. To resolve such
         * ambiguities, the keys can be prefixed with<code>aggregation:</code>, <code>association:</code> or
         * <code>event:</code>.In that case the keys must be quoted due to the ':'.Each subclass should
         * document the set of supported names in its constructor documentation.<b>Valid Values:</b><ul><li>for
         * normal properties, the value has to be of the correct simple type (no type conversion occurs)<li>for
         * 0..1 aggregations, the value has to be an instance of the aggregated control or element type<li>for
         * 0..n aggregations, the value has to be an array of instances of the aggregated type<li>for 0..1
         * associations, an instance of the associated type or an id (string) is accepted<li>0..n associations
         * are not supported yet<li>for events either a function (event handler) is accepted or an array of
         * length 2    where the first element is a function and the 2nd element is an object to invoke the
         * method on.</ul>Special aggregation "dependents" is connected to the lifecycle management and
         * databinding,but not rendered automatically and can be used for popups or other dependent controls.
         * This allowsdefinition of popup controls in declarative views and enables propagation of model and
         * contextinformation to them.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId id for the new control; generated automatically if no non-empty id is given     Note:
         * this can be omitted, no matter whether <code>mSettings</code> will be given or not!
         * @param mSettings optional map/JSON-object with initial property values, aggregated objects etc. for
         * the new element
        */
        constructor(mSettings?: any);


        /**
         * Returns the best suitable DOM node that represents this Element wrapped as jQuery object.I.e. the
         * element returned by {@link sap.ui.core.Element#getDomRef} is wrapped and returned.If an ID suffix is
         * given, the ID of this Element is concatenated with the suffix(separated by a single dash) and the
         * DOM node with that compound ID will be wrapped by jQuery.This matches the UI5 naming convention for
         * named inner DOM nodes of a control.
         * @param sSuffix ID suffix to get a jQuery object for
         * @returns The jQuery wrapped element's DOM reference
        */
        $(sSuffix: string): typeof jQuery;

        /**
         * Adds some customData to the aggregation <code>customData</code>.
         * @param oCustomData the customData to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addCustomData(oCustomData: sap.ui.core.CustomData): sap.ui.core.Element;

        /**
         * Adds some dependent to the aggregation <code>dependents</code>.
         * @since 1.19
         * @param oDependent the dependent to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addDependent(oDependent: sap.ui.core.Control): sap.ui.core.Element;

        /**
         * Adds a delegate that listens to the events that are fired on this element (as opposed to events
         * which are fired BY this element).When this element is cloned, the same delegate will be added to all
         * clones. This behavior is well-suited for applications which want to add delegatesthat also work with
         * templates in aggregation bindings.For control development the internal "addDelegate" method which
         * does not clone delegates by default may be more suitable, as typically each control instance takes
         * care of its own delegates.To avoid double registrations, all registrations of the given delegate are
         * firstremoved and then the delegate is added.<strong>Important:</strong> If event delegates were
         * added the delegate will still be called even ifthe event was processed and/or cancelled via
         * <code>preventDefault</code> by the Element or another event delegate.<code>preventDefault</code>
         * only prevents the event from bubbling.It should be checked e.g. in the event delegate's listener
         * whether an Element is still enabled via <code>getEnabled</code>.Additionally there might be other
         * things that delegates need to check depending on the event(e.g. not adding a key twice to an output
         * string etc.).
         * @since 1.9.0
         * @param oDelegate the delegate object
         * @param oThis if given, this object will be the "this" context in the listener methods; default is
         * the delegate object itself
         * @returns Returns <code>this</code> to allow method chaining
        */
        addEventDelegate(oDelegate: any, oThis?: any): sap.ui.core.Element;

        /**
         * Applies the focus info.To be overwritten by the specific control method.
         * @param oFocusInfo undefined
        */
        applyFocusInfo(oFocusInfo: any): void;

        /**
         * Bind the object to the referenced entity in the model, which is used as the binding contextto
         * resolve bound properties or aggregations of the object itself and all of its childrenrelatively to
         * the given path.If a relative binding path is used, this will be applied whenever the parent context
         * changes.
         * @param vPath the binding path or an object with more detailed binding options
         * @param mParameters map of additional parameters for this binding (only taken into account when vPath
         * is a string in that case the properties described for vPath above are valid here).
         * @returns reference to the instance itself
        */
        bindElement(vPath: string | any, mParameters?: any): sap.ui.base.ManagedObject;

        /**
         * Clone delegates
         * @param sIdSuffix a suffix to be appended to the cloned element id
         * @param aLocalIds an array of local IDs within the cloned hierarchy (internally used)
         * @returns reference to the newly created clone
        */
        clone(sIdSuffix: string, aLocalIds?: string[]): sap.ui.base.ManagedObject;

        /**
         * Creates a new Element from the given data.If vData is an Element already, that element is
         * returned.If vData is an object (literal), then a new element is created with vData as settings.The
         * type of the element is either determined by a "Type" entry in the vData orby a type information in
         * the oKeyInfo object
         * @param vData the data to create the element from
         * @param oKeyInfo an entity information (e.g. aggregation info)
        */
        create(vData: sap.ui.core.Element | any, oKeyInfo?: any): void;

        /**
         * Attaches custom data to an Element or retrieves attached data.Usage:   data("myKey", myData)attaches
         * myData (which can be any JS data type, e.g. a number, a string, an object, or a function) to this
         * element, under the given key "myKey". If the key already exists,the value will be updated.  
         * data("myKey", myData, writeToDom)attaches myData to this element, under the given key "myKey" and
         * (if writeToDom is true) writes key and value to the HTML. If the key already exists,the value will
         * be updated. While oValue can be any JS data type to be attached, it must be a string to be also
         * written to DOM. The key must also be a valid HTML attribute name (it must conform to any
         * and may contain no colon) and may not start with "sap-ui". When written to HTML, the key is prefixed
         * with "data-".   data("myKey")retrieves whatever data has been attached to this Element (using the
         * key "myKey") before   data("myKey", null)removes whatever data has been attached to this Element
         * (using the key "myKey") before   data(null)removes all data   data()returns all data, as a map
        */
        data(): void;

        /**
         * Creates metadata for an UI Element by extending the Object Metadata.In addition to the entries
         * defined by {@link sap.ui.base.Object.defineClass}, the followingentries can be specified in the
         * static info object:<ul><li>library: {string} name of the library that contains the
         * element/control<li>properties: a map of property info objects, mapped by the property name    Info
         * object should contain the following information    <ul>    <li>name {string} name of the property
         * (redundant to map key)    <li>type {string} type of the property    <li>[defaultValue] {any} default
         * value of the property. Can be omitted    </ul><li>aggregations: a map of aggregation info objects,
         * mapped by the aggregation name    Info object should contain the following information    <ul>   
         * <li>name {string} name of the aggregation, singular for 0..1, plural for 0..n    <li>type {string}
         * type of the aggregated controls/elements    <li>multiple {boolean}    <li>singularName {string}
         * singular name for 0..n aggregations    </ul><li>associations: a map of association info objects,
         * mapped by the association name    Info object should contain the following information    <ul>   
         * <li>name {string} name of the association, singular for 0..1, plural for 0..n    <li>type {string}
         * type of the associated controls/elements    <li>multiple {boolean}    <li>singularName {string}
         * singular name for 0..n associations    </ul><li>events: map from event names to event names</ul>
         * @param sClassName name of the class to build the metadata for
         * @param oStaticInfo static information used to build the metadata
         * @param fnMetaImpl constructor to be used for the metadata
         * @returns the created metadata
        */
        defineClass(sClassName: string, oStaticInfo: any, fnMetaImpl?: any): any;

        /**
         * Cleans up the resources associated with this element and all its children.After an element has been
         * destroyed, it can no longer be used in the UI!Applications should call this method if they don't
         * need the element any longer.
         * @param bSuppressInvalidate if true, the UI element is not marked for redraw
        */
        destroy(bSuppressInvalidate: boolean): void;

        /**
         * Destroys all the customData in the aggregation <code>customData</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyCustomData(): sap.ui.core.Element;

        /**
         * Destroys all the dependents in the aggregation <code>dependents</code>.
         * @since 1.19
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyDependents(): sap.ui.core.Element;

        /**
         * Destroys the layoutData in the aggregation <code>layoutData</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyLayoutData(): sap.ui.core.Element;

        /**
         * Destroys the tooltip in the aggregationnamed <code>tooltip</code>.
         * @returns <code>this</code> to allow method chaining
        */
        destroyTooltip(): sap.ui.core.Element;

        /**
         * Allows the parent of a control to enhance the aria information during rendering.This function is
         * called by the RenderManager's writeAccessibilityState methodfor the parent of the currently rendered
         * control - if the parent implements it.
         * @param oElement the Control/Element for which aria properties are rendered
         * @param mAriaProps map of aria properties keyed by there name (withour prefix "aria-")
         * @returns map of enhanced aria properties
        */
        enhanceAccessibilityState(oElement: sap.ui.core.Element, mAriaProps: any): any;

        /**
         * Cleans up the element instance before destruction.Applications must not call this hook method
         * directly, it is called by the frameworkwhen the element is {@link #destroy destroyed}.Subclasses of
         * Element should override this hook to implement any necessary cleanup.
        */
        exit(): void;


        /**
         * Searches and returns an array of child elements and controls which arereferenced within an
         * aggregation or aggregations of child elements/controls.This can be either done recursive or
         * not.<br><b>Take care: this operation might be expensive.</b>
         * @param bRecursive true, if all nested children should be returned.
         * @returns array of child elements and controls
        */
        findElements(bRecursive: boolean): sap.ui.core.Element[];

        /**
         * Fires the given event and notifies all listeners. Listeners must not changethe content of the event.
         * @param sEventId the event id
         * @param mParameters the parameter map
         * @returns Returns <code>this</code> to allow method chaining
        */
        fireEvent(sEventId: string, mParameters: any): sap.ui.core.Element;

        /**
         * Sets the focus to the stored focus DOM reference
        */
        focus(): void;

        /**
         * Gets content of aggregation <code>customData</code>.Custom Data, a data structure like a map
         * containing arbitrary key value pairs.
        */
        getCustomData(): sap.ui.core.CustomData[];

        /**
         * Gets content of aggregation <code>dependents</code>.Dependents are not rendered, but their
         * databinding context and lifecycle are bound to the aggregating Element.
         * @since 1.19
        */
        getDependents(): sap.ui.core.Control[];

        /**
         * Returns the best suitable DOM Element that represents this UI5 Element.By default the DOM Element
         * with the same ID as this Element is returned.Subclasses should override this method if the lookup
         * via id is not sufficient.Note that such a DOM Element does not necessarily exist in all cases.Some
         * elements or controls might not have a DOM representation at all (e.g.a naive FlowLayout) while
         * others might not have one due to their currentstate (e.g. an initial, not yet rendered control).If
         * an ID suffix is given, the ID of this Element is concatenated with the suffix(separated by a single
         * dash) and the DOM node with that compound ID will be returned.This matches the UI5 naming convention
         * for named inner DOM nodes of a control.
         * @param sSuffix ID suffix to get the DOMRef for
         * @returns The Element's DOM Element sub DOM Element or null
        */
        getDomRef(sSuffix: string): sap.ui.core.Element;

        /**
         * Get the element binding object for a specific model
         * @param sModelName the name of the model
         * @returns the element binding for the given model name
        */
        getElementBinding(sModelName: string): sap.ui.model.Binding;

        /**
         * Returns the DOM Element that should get the focus.To be overwritten by the specific control method.
         * @returns Returns the DOM Element that should get the focus
        */
        getFocusDomRef(): sap.ui.core.Element;

        /**
         * Returns an object representing the serialized focus informationTo be overwritten by the specific
         * control method
         * @returns an object representing the serialized focus information
        */
        getFocusInfo(): any;

        /**
        */
        getInterface(): sap.ui.base.Interface;

        /**
         * Gets content of aggregation <code>layoutData</code>.Defines the layout constraints for this control
         * when it is used inside a Layout.LayoutData classes are typed classes and must match the embedding
         * Layout.See VariantLayoutData for aggregating multiple alternative LayoutData instances to a single
         * Element.
        */
        getLayoutData(): sap.ui.core.LayoutData;

        /**
         * Returns a metadata object for class sap.ui.core.Element.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Returns the tooltip for this element if any or an undefined value.The tooltip can either be a simple
         * string or a subclass of{@link sap.ui.core.TooltipBase}.Callers that are only interested in tooltips
         * of type string (e.g. to renderthem as a <code>title</code> attribute), should call the convenience
         * method{@link #getTooltip_AsString} instead. If they want to get a tooltip text nomatter where it
         * comes from (be it a string tooltip or the text from a TooltipBaseinstance) then they could call
         * {@link #getTooltip_Text} instead.
         * @returns The tooltip for this Element.
        */
        getTooltip(): string | sap.ui.core.TooltipBase;

        /**
         * Returns the tooltip for this element but only if it is a simple string.Otherwise an undefined value
         * is returned.
         * @returns string tooltip or undefined
        */
        getTooltip_AsString(): string;

        /**
         * Returns the main text for the current tooltip or undefined if there is no such text.If the tooltip
         * is an object derived from sap.ui.core.Tooltip, then the text propertyof that object is returned.
         * Otherwise the object itself is returned (either a stringor undefined or null).
         * @returns text of the current tooltip or undefined
        */
        getTooltip_Text(): string;

        /**
         * Checks for the provided <code>sap.ui.core.CustomData</code> in the aggregation
         * <code>customData</code>.and returns its index if found or -1 otherwise.
         * @param oCustomData The customData whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfCustomData(oCustomData: sap.ui.core.CustomData): number;

        /**
         * Checks for the provided <code>sap.ui.core.Control</code> in the aggregation
         * <code>dependents</code>.and returns its index if found or -1 otherwise.
         * @since 1.19
         * @param oDependent The dependent whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfDependent(oDependent: sap.ui.core.Control): number;

        /**
         * Initializes the element instance after creation.Applications must not call this hook method
         * directly, it is called by the frameworkwhile the constructor of an element is executed.Subclasses of
         * Element should override this hook to implement any necessary initialization.
        */
        init(): void;

        /**
         * Inserts a customData into the aggregation <code>customData</code>.
         * @param oCustomData the customData to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the customData should be inserted at; for             a
         * negative value of <code>iIndex</code>, the customData is inserted at position 0; for a value        
         *     greater than the current size of the aggregation, the customData is inserted at             the
         * last position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertCustomData(oCustomData: sap.ui.core.CustomData, iIndex: number): sap.ui.core.Element;

        /**
         * Inserts a dependent into the aggregation <code>dependents</code>.
         * @since 1.19
         * @param oDependent the dependent to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the dependent should be inserted at; for             a
         * negative value of <code>iIndex</code>, the dependent is inserted at position 0; for a value         
         *    greater than the current size of the aggregation, the dependent is inserted at             the
         * last position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertDependent(oDependent: sap.ui.core.Control, iIndex: number): sap.ui.core.Element;

        /**
         * This function either calls set[sPropertyName] or get[sPropertyName] with the specified property
         * namedepending if an <code>oValue</code> is provided or not.
         * @param sPropertyName name of the property to set
         * @param oValue value to set the property to
         * @returns Returns <code>this</code> to allow method chaining in case of setter and the property value
         * in case of getter
        */
        prop(sPropertyName: string, oValue?: any): any | sap.ui.core.Element;

        /**
         * Removes all the controls from the aggregation <code>customData</code>.Additionally, it unregisters
         * them from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllCustomData(): sap.ui.core.CustomData[];

        /**
         * Removes all the controls from the aggregation <code>dependents</code>.Additionally, it unregisters
         * them from the hosting UIArea.
         * @since 1.19
         * @returns An array of the removed elements (might be empty)
        */
        removeAllDependents(): sap.ui.core.Control[];

        /**
         * Removes a customData from the aggregation <code>customData</code>.
         * @param vCustomData The customData to remove or its index or id
         * @returns The removed customData or <code>null</code>
        */
        removeCustomData(vCustomData: number | string | sap.ui.core.CustomData): sap.ui.core.CustomData;

        /**
         * Removes a dependent from the aggregation <code>dependents</code>.
         * @since 1.19
         * @param vDependent The dependent to remove or its index or id
         * @returns The removed dependent or <code>null</code>
        */
        removeDependent(vDependent: number | string | sap.ui.core.Control): sap.ui.core.Control;

        /**
         * Removes the given delegate from this element.This method will remove all registrations of the given
         * delegate, not only one.
         * @since 1.9.0
         * @param oDelegate the delegate object
         * @returns Returns <code>this</code> to allow method chaining
        */
        removeEventDelegate(oDelegate: any): sap.ui.core.Element;

        /**
         * This triggers immediate rerendering of its parent and thus of itself and its children.<br/> As
         * <code>sap.ui.core.Element</code> "bubbles up" thererender, changes to child-<code>Elements</code>
         * will also result in immediate rerendering of the whole sub tree.
        */
        rerender(): void;

        /**
         * Sets the {@link sap.ui.core.LayoutData} defining the layout constraintsfor this control when it is
         * used inside a layout.
         * @param oLayoutData undefined
        */
        setLayoutData(oLayoutData: sap.ui.core.LayoutData): void;

        /**
         * Sets a new tooltip for this object. The tooltip can either be a simple string(which in most cases
         * will be rendered as the <code>title</code> attribute of thisElement) or an instance of {@link
         * sap.ui.core.TooltipBase}.If a new tooltip is set, any previously set tooltip is deactivated.
         * @param vTooltip undefined
        */
        setTooltip(vTooltip: string | sap.ui.core.TooltipBase): void;

        /**
         * Returns a simple string representation of this element.Mainly useful for tracing purposes.
         * @returns a string descripition of this element
        */
        toString(): string;

        /**
         * Removes the defined binding context of this object, all bindings will now resolverelative to the
         * parent context again.
         * @param sModelName undefined
         * @returns reference to the instance itself
        */
        unbindElement(sModelName: string): sap.ui.base.ManagedObject;
      }
      /**
       * This element used to provide messages. Rendering must be done within the control that uses this kind
       * of element.Its default level is none.
       * @resource sap/ui/core/Message.js
      */
      export class Message extends sap.ui.core.Element {


        /**
         * Constructor for a new Message.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Compares the given message with <code>this</code> message. The types of{@link
         * sap.ui.core.MessageType} are ordered from "Error" > "Warning" > "Success" >"Information" >
         * "None".See  {@link sap.ui.core.Message.compareByType}
         * @param oOther message to compare with this one
         * @returns returns <code>0</code> if both messages are at        the same level. <code>-1</code> if
         * <code>this</code>        message has a lower level. <code>1</code> if <code>this</code>       
         * message has a higher level.
        */
        compareByType(oOther: typeof sap.ui.core.Message): number;

        /**
         * Compares two given messages with each other.The types of {@link sap.ui.core.MessageType} are ordered
         * from "Error" > "Warning" > "Success" >"Information" > "None".
         * @param oMessage1 first message to compare
         * @param oMessage2 second message to compare
         * @returns returns <code>0</code> if both messages are at        the same level. <code>-1</code> if
         * <code>this</code>        message has a lower level. <code>1</code> if <code>this</code>       
         * message has a higher level.
        */
        compareByType(oMessage1: typeof sap.ui.core.Message, oMessage2: typeof sap.ui.core.Message): number;


        /**
         * Returns the icon's default URI depending on given size.There are default icons for messages
         * available that can be used this way. If noparameter is given, the size will be 16x16 per default. If
         * larger icons are needed,the parameter "32x32" might be given.
         * @param sSize If parameter is not set the default icon's size will be 16x16. If parameter        is
         * set to "32x32" the icon size will be 32x32.
         * @returns URI of the default icon.
        */
        getDefaultIcon(sSize: string): any;

        /**
         * Gets current value of property <code>icon</code>.A possible icon URI of the message
         * @returns Value of property <code>icon</code>
        */
        getIcon(): any;

        /**
         * Gets current value of property <code>level</code>.Setting the message's level.Default value is
         * <code>None</code>.
         * @returns Value of property <code>level</code>
        */
        getLevel(): sap.ui.core.MessageType;

        /**
         * Returns a metadata object for class sap.ui.core.Message.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>readOnly</code>.Determines whether the message should be read
         * only. This helps the application to handle a message a different way if the application
         * differentiates between read-only and common messages.Default value is <code>false</code>.
         * @since 1.19.0
         * @returns Value of property <code>readOnly</code>
        */
        getReadOnly(): boolean;

        /**
         * Gets current value of property <code>text</code>.Message text
         * @returns Value of property <code>text</code>
        */
        getText(): string;

        /**
         * Gets current value of property <code>timestamp</code>.Message's timestamp. It is just a simple
         * String that will be used without any transformation. So the application that uses messages needs to
         * format the timestamp to its own needs.
         * @returns Value of property <code>timestamp</code>
        */
        getTimestamp(): string;

        /**
         * Sets a new value for property <code>icon</code>.A possible icon URI of the messageWhen called with a
         * value of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.
         * @param sIcon New value for property <code>icon</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setIcon(sIcon: any): typeof sap.ui.core.Message;

        /**
         * Sets a new value for property <code>level</code>.Setting the message's level.When called with a
         * value of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>None</code>.
         * @param sLevel New value for property <code>level</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setLevel(sLevel: sap.ui.core.MessageType): typeof sap.ui.core.Message;

        /**
         * Sets a new value for property <code>readOnly</code>.Determines whether the message should be read
         * only. This helps the application to handle a message a different way if the application
         * differentiates between read-only and common messages.When called with a value of <code>null</code>
         * or <code>undefined</code>, the default value of the property will be restored.Default value is
         * <code>false</code>.
         * @since 1.19.0
         * @param bReadOnly New value for property <code>readOnly</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setReadOnly(bReadOnly: boolean): typeof sap.ui.core.Message;

        /**
         * Sets a new value for property <code>text</code>.Message textWhen called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
         * @param sText New value for property <code>text</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setText(sText: string): typeof sap.ui.core.Message;

        /**
         * Sets a new value for property <code>timestamp</code>.Message's timestamp. It is just a simple String
         * that will be used without any transformation. So the application that uses messages needs to format
         * the timestamp to its own needs.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.
         * @param sTimestamp New value for property <code>timestamp</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setTimestamp(sTimestamp: string): typeof sap.ui.core.Message;
      }
      /**
       * Base Class for Controls.
       * @resource sap/ui/core/Control.js
      */
      export abstract class Control extends sap.ui.core.Element {


        /**
         * Creates and initializes a new control with the given <code>sId</code> and settings.The set of
         * allowed entries in the <code>mSettings</code> object depends on the concretesubclass and is
         * described there. See {@link sap.ui.core.Element} for a general description of thisargument.The
         * settings supported by Control are:<ul><li>Properties<ul><li>{@link #getBusy busy} : boolean
         * (default: false)</li><li>{@link #getBusyIndicatorDelay busyIndicatorDelay} : int (default:
         * 1000)</li></ul></li></ul>Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId optional id for the new control; generated automatically if no non-empty id is given    
         * Note: this can be omitted, no matter whether <code>mSettings</code> will be given or not!
         * @param mSettings optional map/JSON-object with initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * The string given as "sStyleClass" will be added to the "class" attribute of this control's root HTML
         * element.This method is intended to be used to mark controls as being of a special type for
         * whichspecial styling can be provided using CSS selectors that reference this style class
         * name.<pre>Example:   myButton.addStyleClass("myRedTextButton"); // add a CSS class to one button
         * instance...and in CSS:   .myRedTextButton {      color: red;   }</pre>This will add the CSS class
         * "myRedTextButton" to the Button HTML and the CSS code above will thenmake the text in this
         * particular button red.Only characters allowed inside HTML attributes are allowed.Quotes are not
         * allowed and this method will ignore any strings containing quotes.Strings containing spaces are
         * interpreted as multiple custom style classes which are split by space and can be removedindividually
         * later by calling removeStyleClass.Multiple calls with the same sStyleClass will have no different
         * effect than calling once.If sStyleClass is null, empty string or it contains quotes, the call is
         * ignored.
         * @param sStyleClass the CSS class name to be added
         * @returns Returns <code>this</code> to allow method chaining
        */
        addStyleClass(): sap.ui.core.Control;

        /**
         * Defines whether the user can select text inside this control.Defaults to <code>true</code> as long
         * as this method has not been called.<b>Note:</b>This only works in IE and Safari; for Firefox the
         * element's style mustbe set to:<pre>  -moz-user-select: none;</pre>in order to prevent text
         * selection.
         * @param bAllow whether to allow text selection or not
         * @returns Returns <code>this</code> to allow method chaining
        */
        allowTextSelection(bAllow: boolean): sap.ui.core.Control;

        /**
         * Allows binding handlers for any native browser event to the root HTML element of this Control. This
         * internally handlesDOM element replacements caused by re-rendering.IMPORTANT:This should be only used
         * as FALLBACK when the Control events do not cover a specific use-case! Always try usingSAPUI5 control
         * events, as e.g. accessibility-related functionality is then provided automatically.E.g. when working
         * with a sap.ui.commons.Button, always use the Button's "press" event, not the native "click" event,
         * because"press" is also guaranteed to be fired when certain keyboard activity is supposed to trigger
         * the Button.In the event handler, "this" refers to the Control - not to the root DOM element like in
         * jQuery. While the DOM element canbe used and modified, the general caveats for working with SAPUI5
         * control DOM elements apply. In particular the DOM elementmay be destroyed and replaced by a new one
         * at any time, so modifications that are required to have permanent effect may notbe done. E.g. use
         * Control.addStyleClass() instead if the modification is of visual nature.Use detachBrowserEvent() to
         * remove the event handler(s) again.
         * @param sEventType A string containing one or more JavaScript event types, such as "click" or "blur".
         * @param fnHandler A function to execute each time the event is triggered.
         * @param oListener The object, that wants to be notified, when the event occurs
         * @returns Returns <code>this</code> to allow method chaining
        */
        attachBrowserEvent(sEventType: string, fnHandler?: any, oListener?: any): sap.ui.core.Control;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>validateFieldGroup</code> event of this
         * <code>sap.ui.core.Control</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.core.Control</code> itself.Event is fired if a logical field group defined by
         * <code>fieldGroupIds</code> of a control was left or the user explicitly pressed a validation key
         * combination.Use this event to validate data of the controls belonging to a field group.
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.core.Control</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachValidateFieldGroup(oData: any, fnFunction: any, oListener?: any): sap.ui.core.Control;

        /**
         * Returns whether the control has a given field group.If <code>vFieldGroupIds</code> is not given it
         * checks whether at least one field group ID is given for this control.If <code>vFieldGroupIds</code>
         * is an empty array or empty string, true is returned if there is no field group ID set for this
         * control.If <code>vFieldGroupIds</code> is a string array or a string all expected field group IDs
         * are checked and true is returned if all are contained for given for this control.The comma delimiter
         * can be used to seperate multiple field group IDs in one string.
         * @param vFieldGroupIds ID of the field group or an array of field group IDs to match
         * @returns true if a field group ID matches
        */
        checkFieldGroupIds(vFieldGroupIds: string | string[]): boolean;

        /**
         * Overrides {@link sap.ui.core.Element#clone Element.clone} to clone additionalinternal state.The
         * additionally cloned information contains:<ul><li>browser event handlers attached with {@link
         * #attachBrowserEvent}<li>text selection behavior<li>style classes added with {@link
         * #addStyleClass}</ul>
         * @param sIdSuffix a suffix to be appended to the cloned element id
         * @param aLocalIds an array of local IDs within the cloned hierarchy (internally used)
         * @returns reference to the newly created clone
        */
        clone(sIdSuffix: string, aLocalIds?: string[]): sap.ui.base.ManagedObject;

        /**
         * Removes event handlers which have been previously attached using {@link #attachBrowserEvent}.Note:
         * listeners are only removed, if the same combination of event type, callback functionand context
         * object is given as in the call to <code>attachBrowserEvent</code>.
         * @param sEventType A string containing one or more JavaScript event types, such as "click" or "blur".
         * @param fnHandler The function that is to be no longer executed.
         * @param oListener The context object that was given in the call to attachBrowserEvent.
        */
        detachBrowserEvent(sEventType: string, fnHandler?: any, oListener?: any): void;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>validateFieldGroup</code> event of
         * this <code>sap.ui.core.Control</code>.The passed function and listener object must match the ones
         * used for event registration.
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachValidateFieldGroup(fnFunction: any, oListener: any): sap.ui.core.Control;


        /**
         * Fires event <code>validateFieldGroup</code> to attached listeners.Expects the following event
         * parameters:<ul><li><code>fieldGroupIds</code> of type <code>string[]</code>field group IDs of the
         * logical field groups to validate</li></ul>
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireValidateFieldGroup(mArguments: any): sap.ui.core.Control;

        /**
         * This function (if available on the concrete control) providesthe current accessibility state of the
         * control.Applications must not call this hook method directly, it is called by the
         * framework.Subclasses of Control should implement this hook to provide any necessary accessibility
         * information:<pre>MyControl.prototype.getAccessibilityInfo = function() {   return {     role:
         * "textbox",      // String which represents the WAI-ARIA role which is implemented by the control.   
         *  type: "date input",   // String which represents the control type (Must be a translated text).
         * Might correlate with                           // the role.     description: "value", // String
         * which describes the most relevant control state (e.g. the inputs value). Must be a                  
         *         // translated text.                           // Note: The type and the enabled/editable
         * state must not be handled here.     focusable: true,      // Boolean which describes whether the
         * control can get the focus.     enabled: true,        // Boolean which describes whether the control
         * is enabled. If not relevant it must not be set or                           // <code>null</code> can
         * be provided.     editable: true,       // Boolean which describes whether the control is editable.
         * If not relevant it must not be set or                           // <code>null</code> can be
         * provided.     children: []          // Array of accessibility info objects of children of the given
         * control (e.g. when the control is a layout).                           // Note: Children should only
         * be provided when it is helpful to understand the accessibility context                           // 
         *      (e.g. a form control must not provide details of its internals (fields, labels, ...) but a     
         *                      //       layout should).   };};</pre>Note: The returned object provides the
         * accessibility state of the control at the point in time when this function is called.
         * @since 1.37.0
         * @returns Current accessibility state of the control.
        */
        getAccessibilityInfo(): any;

        /**
         * Gets current value of property <code>busy</code>.Whether the control is currently in busy
         * state.Default value is <code>false</code>.
         * @returns Value of property <code>busy</code>
        */
        getBusy(): boolean;

        /**
         * Gets current value of property <code>busyIndicatorDelay</code>.The delay in milliseconds, after
         * which the busy indicator will show up for this control.Default value is <code>1000</code>.
         * @returns Value of property <code>busyIndicatorDelay</code>
        */
        getBusyIndicatorDelay(): number;

        /**
         * Returns a list of all child controls with a field group ID.See {@link #checkFieldGroupIds
         * checkFieldGroupIds} for a description of the<code>vFieldGroupIds</code> parameter.Associated
         * controls are not taken into account.
         * @param vFieldGroupIds ID of the field group or an array of field group IDs to match
         * @returns The list of controls with a field group ID
        */
        getControlsByFieldGroupId(vFieldGroupIds: string | string[]): sap.ui.core.Control[];

        /**
         * Returns a copy of the field group IDs array. Modification of the field group IDsneed to call {@link
         * #setFieldGroupIds setFieldGroupIds} to apply the changes.
         * @returns copy of the field group IDs
        */
        getFieldGroupIds(): string[];

        /**
         * Returns the DOMNode Id to be used for the "labelFor" attribute of the label.By default, this is the
         * Id of the control itself.
         * @returns Id to be used for the <code>labelFor</code>
        */
        getIdForLabel(): string;

        /**
         * Returns a metadata object for class sap.ui.core.Control.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Returns a renderer for this control instance.It is retrieved using the RenderManager as done during
         * rendering.
         * @returns a Renderer suitable for this Control instance.
        */
        getRenderer(): any;

        /**
         * Gets current value of property <code>visible</code>.Whether the control should be visible on the
         * screen. If set to false, a placeholder is rendered instead of the real controlDefault value is
         * <code>true</code>.
         * @returns Value of property <code>visible</code>
        */
        getVisible(): boolean;

        /**
         * Returns true if the given style class or all multiple style classes which are generated by splitting
         * the given string with space are already set on the controlvia previous call(s) to addStyleClass().
         * @param sStyleClass the style to check for
        */
        hasStyleClass(sStyleClass: string): boolean;

        /**
         * Triggers rerendering of this element and its children.As <code>sap.ui.core.Element</code> "bubbles
         * up" the invalidate, changes to childrenpotentially result in rerendering of the whole sub tree.
         * @param oOrigin undefined
        */
        invalidate(oOrigin?: any): void;

        /**
         * Check if the control is currently in busy state
        */
        isBusy(): void;

        /**
         * Function is called when the rendering of the control is completed.Applications must not call this
         * hook method directly, it is called by the framework.Subclasses of Control should override this hook
         * to implement any necessary actions after the rendering.
        */
        onAfterRendering(): void;

        /**
         * Function is called before the rendering of the control is started.Applications must not call this
         * hook method directly, it is called by the framework.Subclasses of Control should override this hook
         * to implement any necessary actions before the rendering.
        */
        onBeforeRendering(): void;

        /**
         * Puts <code>this</code> control into the specified container (<code>oRef</code>) at the givenposition
         * (<code>oPosition</code>).First it is checked whether <code>oRef</code> is a container element /
         * control (has amultiple aggregation with type <code>sap.ui.core.Control</code> and name 'content') or
         * is an Id Stringof such an container.If this is not the case <code>oRef</code> can either be a Dom
         * Reference or Id String of the UIArea(if it does not yet exist implicitly a new UIArea is
         * created),The <code>oPosition</code> can be one of the following:<ul> <li>"first": The control is
         * added as the first element to the container.</li> <li>"last": The control is added as the last
         * element to the container (default).</li> <li>"only": All existing children of the container are
         * removed (not destroyed!) and the control is added as new child.</li> <li><i>index</i>: The control
         * is added at the specified <i>index</i> to the container.</li></ul>
         * @param oRef container into which the control should be put
         * @param oPosition Describes the position where the control should be put into the container
         * @returns Returns <code>this</code> to allow method chaining
        */
        placeAt(oRef: string | sap.ui.core.Element | sap.ui.core.Control, oPosition: string | number): sap.ui.core.Control;


        /**
         * Puts <code>this</code> control into the specified container (<code>oRef</code>) at the givenposition
         * (<code>oPosition</code>).First it is checked whether <code>oRef</code> is a container element /
         * control (has amultiple aggregation with type <code>sap.ui.core.Control</code> and name 'content') or
         * is an Id Stringof such an container.If this is not the case <code>oRef</code> can either be a Dom
         * Reference or Id String of the UIArea(if it does not yet exist implicitly a new UIArea is
         * created),The <code>oPosition</code> can be one of the following:<ul> <li>"first": The control is
         * added as the first element to the container.</li> <li>"last": The control is added as the last
         * element to the container (default).</li> <li>"only": All existing children of the container are
         * removed (not destroyed!) and the control is added as new child.</li> <li><i>index</i>: The control
         * is added at the specified <i>index</i> to the container.</li></ul>
         * @param oRef container into which the control should be put
         * @param oPosition Describes the position where the control should be put into the container
         * @returns Returns <code>this</code> to allow method chaining
        */
        placeAt(oPosition: string | number): sap.ui.core.Control;

        /**
         * Removes the given string from the list of custom style classes that have been set previously.Regular
         * style classes like "sapUiBtn" cannot be removed.
         * @param sStyleClass the style to be removed
         * @returns Returns <code>this</code> to allow method chaining
        */
        removeStyleClass(sStyleClass: string): sap.ui.core.Control;

        /**
         * Tries to replace its DOM reference by re-rendering.
        */
        rerender(): void;

        /**
         * Set the controls busy state.
         * @param bBusy The new busy state to be set
         * @returns <code>this</code> to allow method chaining
        */
        setBusy(bBusy: boolean): sap.ui.core.Control;

        /**
         * Define the delay, after which the busy indicator will show up
         * @param iDelay The delay in ms
         * @returns <code>this</code> to allow method chaining
        */
        setBusyIndicatorDelay(iDelay: number): sap.ui.core.Control;

        /**
         * Sets a new value for property <code>fieldGroupIds</code>.The IDs of a logical field group that this
         * control belongs to. All fields in a logical field group should share the same
         * <code>fieldGroupId</code>.Once a logical field group is left, the validateFieldGroup event is
         * raised.When called with a value of <code>null</code> or <code>undefined</code>, the default value of
         * the property will be restored.Default value is <code>[]</code>.
         * @since 1.31
         * @param sFieldGroupIds New value for property <code>fieldGroupIds</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setFieldGroupIds(sFieldGroupIds: string[]): sap.ui.core.Control;

        /**
         * Sets a new value for property <code>visible</code>.Whether the control should be visible on the
         * screen. If set to false, a placeholder is rendered instead of the real controlWhen called with a
         * value of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>true</code>.
         * @param bVisible New value for property <code>visible</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setVisible(bVisible: boolean): sap.ui.core.Control;

        /**
         * The string given as "sStyleClass" will be be either added to or removed from the "class" attribute
         * of this control's root HTML element,depending on the value of "bAdd": if bAdd is true, sStyleClass
         * will be added.If bAdd is not given, sStyleClass will be removed if it is currently present and will
         * be added if not present.If sStyleClass is null or empty string, the call is ignored.See
         * addStyleClass and removeStyleClass for further documentation.
         * @param sStyleClass the CSS class name to be added or removed
         * @param bAdd whether sStyleClass should be added (or removed); when this parameter is not given,
         * sStyleClass will be toggled (removed, if present, and added if not present)
         * @returns Returns <code>this</code> to allow method chaining
        */
        toggleStyleClass(sStyleClass: string, bAdd: boolean): sap.ui.core.Control;

        /**
         * Triggers the validateFieldGroup event for this control.Called by sap.ui.core.UIArea if a field group
         * should be validated after is loses the focus or a validation key combibation was pressed.The
         * validation key is defined in the UI area <code>UIArea._oFieldGroupValidationKey</code>
        */
        triggerValidateFieldGroup(): void;
      }
      /**
       * History handles the history of certain controls (e.g. sap.ui.commons.SearchField).
       * @resource sap/ui/core/History.js
      */
      export class History extends sap.ui.base.Object {






        /**
         * Returns a metadata object for class sap.ui.core.History.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;
      }
      /**
       * Fragments support the definition of light-weight stand-alone UI control trees.This class acts as
       * factory which returns the UI control tree defined inside the Fragments. When used within declarative
       * Views,the Fragment content is imported and seamlessly integrated into the View.Fragments are used
       * similar as sap.ui.core.mvc.Views, but Fragments do not have a Controller on their own (they may know
       * one, though),they are not a Control, they are not part of the UI tree and they have no
       * representation in HTML.By default, in contrast to declarative Views, they do not do anything to
       * guarantee ID uniqueness.But like Views they can be defined in several Formats (XML, declarative
       * HTML, JavaScript; support for other types can be plugged in),the declaration syntax is the same as
       * in declarative Views and the name and location of the Fragment files is similar to Views.Controller
       * methods can also be referenced in the declarations, but as Fragments do not have their own
       * controllers,this requires the Fragments to be used within a View which does have a controller.That
       * controller is used, then.Do not call the Fragment constructor directly!Use-cases for Fragments are
       * e.g.:- Modularization of UIs without fragmenting the controller structure- Re-use of UI parts-
       * 100%-declarative definition of Views
       * @resource sap/ui/core/Fragment.js
      */
      export class Fragment extends sap.ui.base.ManagedObject {


        /**
         * Accepts an object literal <code>mSettings</code> that defines initialproperty values, aggregated and
         * associated objects as well as event handlers.See {@link sap.ui.base.ManagedObject#constructor} for a
         * general description of the syntax of the settings object.
        */
        constructor();



        /**
         * Returns an Element/Control by its ID in the context of the Fragment with the given ID
         * @param sFragmentId undefined
         * @param sId undefined
        */
        byId(sFragmentId: string, sId: string): void;

        /**
         * Returns the ID which a Control with the given ID in the context of the Fragment with the given ID
         * would have
         * @param sFragmentId undefined
         * @param sId undefined
        */
        createId(sFragmentId: string, sId: string): void;


        /**
         * Returns a metadata object for class sap.ui.core.Fragment.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>type</code>.
         * @returns Value of property <code>type</code>
        */
        getType(): string;

        /**
         * Registers a new Fragment type
         * @param sType the Fragment type. Types "XML", "HTML" and JS" are built-in and always available.
         * @param oFragmentImpl an object having a property "init" of type "function" which is called on
         * Fragment instantiation with the settings map as argument
        */
        registerType(sType: string, oFragmentImpl: any): void;

        /**
         * Sets a new value for property <code>type</code>.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.
         * @param sType New value for property <code>type</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setType(sType: string): sap.ui.core.Fragment;
      }
      /**
       * An item that is used in lists or list-similar controls such as DropdownBox, for example.The element
       * foresees the usage of additional texts displayed in a second column.
       * @resource sap/ui/core/ListItem.js
      */
      export class ListItem extends sap.ui.core.Item {


        /**
         * Constructor for a new ListItem.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);




        /**
         * Gets current value of property <code>additionalText</code>.Some additional text of type string,
         * optionally to be displayed along with this item.
         * @returns Value of property <code>additionalText</code>
        */
        getAdditionalText(): string;

        /**
         * Gets current value of property <code>icon</code>.The icon belonging to this list item instance.This
         * can be an URI to an image or an icon font URI.
         * @returns Value of property <code>icon</code>
        */
        getIcon(): string;

        /**
         * Returns a metadata object for class sap.ui.core.ListItem.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Sets a new value for property <code>additionalText</code>.Some additional text of type string,
         * optionally to be displayed along with this item.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.
         * @param sAdditionalText New value for property <code>additionalText</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setAdditionalText(sAdditionalText: string): sap.ui.core.ListItem;

        /**
         * Sets a new value for property <code>icon</code>.The icon belonging to this list item instance.This
         * can be an URI to an image or an icon font URI.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.
         * @param sIcon New value for property <code>icon</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setIcon(sIcon: string): sap.ui.core.ListItem;
      }
      /**
       * The Manifest class.
       * @resource sap/ui/core/Manifest.js
      */
      export class Manifest extends sap.ui.base.Object {


        /**
         * Creates and initializes a manifest wrapper which provides API access tothe content of the manifest.
         * @param oManifest the manifest object
         * @param mOptions (optional) the configuration options
        */
        constructor(oManifest: any, mOptions?: any);




        /**
         * Returns the Component name which is defined in the manifest as<code>sap.ui5/componentName</code> or
         * <code>sap.app/id</code>
         * @returns the component name
        */
        getComponentName(): string;

        /**
         * Returns the configuration of a manifest section or the value for aspecific path. If no key is
         * specified, the return value is null.Example:<code>  {    "sap.ui5": {      "dependencies": {       
         * "libs": {          "sap.m": {}        },        "components": {          "my.component.a": {}       
         * }      }  });</code>The configuration above can be accessed in the following ways:<ul><li><b>By
         * section/namespace</b>: <code>oManifest.getEntry("sap.ui5")</code></li><li><b>By path</b>:
         * <code>oManifest.getEntry("/sap.ui5/dependencies/libs")</code></li></ul>By section/namespace returns
         * the configuration for the specified manifestsection and by path allows to specify a concrete path to
         * a dedicated entryinside the manifest. The path syntax always starts with a slash (/).
         * @param sKey Either the manifest section name (namespace) or a concrete path
         * @returns Value of the key (could be any kind of value)
        */
        getEntry(sKey: string): any | any;

        /**
         * Returns the manifest defined in the metadata of the component.If not specified, the return value is
         * null.
         * @returns manifest.
        */
        getJson(): any;

        /**
         * Returns a metadata object for class sap.ui.core.Manifest.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Returns the raw manifest defined in the metadata of the component.If not specified, the return value
         * is null.
         * @returns manifest
        */
        getRawJson(): any;

        /**
         * Function to load the manifest by URL
         * @param mOptions the configuration options
         * @returns Manifest object or for asynchronous calls an ECMA Script 6 Promise object will be returned.
        */
        load(mOptions: any): sap.ui.core.Manifest | JQueryPromise<any>;
      }
      /**
       * Provides eventing capabilities for applications like firing events and attaching or detaching event 
       *      handlers for events which are notified when events are fired.
       * @resource sap/ui/core/EventBus.js
      */
      export class EventBus extends sap.ui.base.Object {


        /**
         * Creates an instance of EventBus.
        */
        constructor();



        /**
         * Cleans up the internal structures and removes all event handlers.The object must not be used anymore
         * after destroy was called.
        */
        destroy(bSuppressInvalidate: boolean): void;


        /**
         * Returns a metadata object for class sap.ui.core.EventBus.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Fires an event using the specified settings and notifies all attached event handlers.
         * @param sChannelId The channel of the event to fire. If not given, the default channel is used. The
         * channel <code>"sap.ui"</code> is                        reserved by the UI5 framework. An
         * application might listen to events on this channel but is not allowed                        to
         * publish its own events there.
         * @param sEventId The identifier of the event to fire
         * @param oData The parameters which should be carried by the event
        */
        publish(sChannelId: string, sEventId: string, oData?: any): void;

        /**
         * Attaches an event handler to the event with the given identifier on the given event channel.
         * @param sChannelId The channel of the event to subscribe to. If not given, the default channel is
         * used.                        The channel <code>"sap.ui"</code> is reserved by the UI5 framework. An
         * application might listen to                        events on this channel but is not allowed to
         * publish its own events there.
         * @param sEventId The identifier of the event to listen for
         * @param fnFunction The handler function to call when the event occurs. This function will be called
         * in the context of the                      <code>oListener</code> instance (if present) or on the
         * event bus instance. The channel is provided as first argument of the handler, and                   
         *   the event identifier is provided as the second argument. The parameter map carried by the event is
         * provided as the third argument (if present).                      Handlers must not change the
         * content of this map.
         * @param oListener The object that wants to be notified when the event occurs (<code>this</code>
         * context within the                       handler function). If it is not specified, the handler
         * function is called in the context of the event bus.
         * @returns Returns <code>this</code> to allow method chaining
        */
        subscribe(sChannelId: string, sEventId: string, fnFunction: any, oListener?: any): sap.ui.core.EventBus;

        /**
         * Attaches an event handler, called one time only, to the event with the given identifier on the given
         * event channel.When the event occurs, the handler function is called and the handler registration is
         * automatically removed afterwards.
         * @since 1.32.0
         * @param sChannelId The channel of the event to subscribe to. If not given, the default channel is
         * used.                        The channel <code>"sap.ui"</code> is reserved by the UI5 framework. An
         * application might listen to                        events on this channel but is not allowed to
         * publish its own events there.
         * @param sEventId The identifier of the event to listen for
         * @param fnFunction The handler function to call when the event occurs. This function will be called
         * in the context of the                      <code>oListener</code> instance (if present) or on the
         * event bus instance. The channel is provided as first argument of the handler, and                   
         *   the event identifier is provided as the second argument. The parameter map carried by the event is
         * provided as the third argument (if present).                      Handlers must not change the
         * content of this map.
         * @param oListener The object that wants to be notified when the event occurs (<code>this</code>
         * context within the                       handler function). If it is not specified, the handler
         * function is called in the context of the event bus.
         * @returns Returns <code>this</code> to allow method chaining
        */
        subscribeOnce(sChannelId: string, sEventId: string, fnFunction: any, oListener?: any): sap.ui.core.EventBus;

        /**
         * Removes a previously subscribed event handler from the event with the given identifier on the given
         * event channel.The passed parameters must match those used for registration with {@link #subscribe }
         * beforehand!
         * @param sChannelId The channel of the event to unsubscribe from. If not given, the default channel is
         * used.
         * @param sEventId The identifier of the event to unsubscribe from
         * @param fnFunction The handler function to unsubscribe from the event
         * @param oListener The object that wanted to be notified when the event occurred
         * @returns Returns <code>this</code> to allow method chaining
        */
        unsubscribe(sChannelId: string, sEventId: string, fnFunction: any, oListener?: any): sap.ui.core.EventBus;
      }
      /**
       * Base Class for Component.
       * @resource sap/ui/core/Component.js
      */
      export abstract class Component extends sap.ui.base.ManagedObject {


        /**
         * Creates and initializes a new Component with the given <code>sId</code> andsettings.The set of
         * allowed entries in the <code>mSettings</code> object depends onthe concrete subclass and is
         * described there. See {@link sap.ui.core.Component}for a general description of this argument.Accepts
         * an object literal <code>mSettings</code> that defines initialproperty values, aggregated and
         * associated objects as well as event handlers.See {@link sap.ui.base.ManagedObject#constructor} for a
         * general description of the syntax of the settings object.This class does not have its own settings,
         * but all settings applicable to the base type{@link sap.ui.base.ManagedObject#constructor
         * sap.ui.base.ManagedObject} can be used.
         * @param sId Optional ID for the new control; generated automatically if           no non-empty ID is
         * given. Note: this can be omitted, no matter           whether <code>mSettings</code> are given or
         * not!
         * @param mSettings Optional map or JSON-object with initial settings for the           new Component
         * instance
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Cleans up the Component instance before destruction.Applications must not call this hook method
         * directly, it is called by theframework when the element is {@link #destroy destroyed}.Subclasses of
         * Component should override this hook to implement any necessarycleanup.
        */
        exit(): void;


        /**
         * Returns user specific data object
         * @since 1.15.0
         * @returns componentData
        */
        getComponentData(): any;

        /**
         * Returns the event bus of this component.
         * @since 1.20.0
         * @returns the event bus
        */
        getEventBus(): sap.ui.core.EventBus;

        /**
        */
        getInterface(): sap.ui.base.Interface;

        /**
         * Returns the manifest defined in the metadata of the component.If not specified, the return value is
         * null.
         * @since 1.33.0
         * @returns manifest.
        */
        getManifest(): any;

        /**
         * Returns the configuration of a manifest section or the value for aspecific path. If no section or
         * key is specified, the return value is null.Example:<code>  {    "sap.ui5": {      "dependencies": { 
         *       "libs": {          "sap.m": {}        },        "components": {          "my.component.a": {} 
         *       }      }  });</code>The configuration above can be accessed in the following
         * ways:<ul><li><b>By section/namespace</b>:
         * <code>oComponent.getManifestEntry("sap.ui5")</code></li><li><b>By path</b>:
         * <code>oComponent.getManifestEntry("/sap.ui5/dependencies/libs")</code></li></ul>By section/namespace
         * returns the configuration for the specified manifestsection and by path allows to specify a concrete
         * path to a dedicated entryinside the manifest. The path syntax always starts with a slash (/).
         * @since 1.33.0
         * @param sKey Either the manifest section name (namespace) or a concrete path
         * @returns Value of the manifest section or the key (could be any kind of value)
        */
        getManifestEntry(sKey: string): any | any;

        /**
         * Returns the manifest object.
         * @since 1.33.0
         * @returns manifest.
        */
        getManifestObject(): sap.ui.core.Manifest;

        /**
         * Returns the metadata for the specific class of the current instance.
         * @returns Metadata for the specific class of the current instance.
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Returns the Component instance in whose "context" the given ManagedObject has been createdor
         * <code>undefined</code>.This is a convenience wrapper around {@link
         * sap.ui.core.Component.getOwnerIdFor Component.getOwnerIdFor}.If the owner ID cannot be determined
         * for reasons documented on <code>getOwnerForId</code>or when the Component for the determined ID no
         * longer exists, <code>undefined</code>will be returned.
         * @since 1.25.1
         * @param oObject Object to retrieve the owner Component for
         * @returns the owner Component or <code>undefined</code>.
        */
        getOwnerComponentFor(oObject: sap.ui.base.ManagedObject): sap.ui.core.Component;

        /**
         * Returns the ID of the object in whose "context" the given ManagedObject has been created.For objects
         * that are not ManagedObjects or for which the owner is unknown,<code>undefined</code> will be
         * returned as owner ID.<strong>Note</strong>: Ownership for objects is only checked by the framework
         * at the timewhen they are created. It is not checked or updated afterwards. And it can only be
         * detectedwhile the {@link sap.ui.core.Component.runAsOwner Component.runAsOwner} function is
         * executing.Without further action, this is only the case while the content of an UIComponent is{@link
         * sap.ui.core.UIComponent.createContent constructed} or when a{@link sap.ui.core.routing.Router
         * Router} creates a new View and its content.<strong>Note</strong>: This method does not guarantee
         * that the returned owner ID belongsto a Component. Currently, it always does. But future versions of
         * UI5 might introduce amore fine grained ownership concept, e.g. taking Views into account. Callers
         * thatwant to deal only with components as owners, should use the following method:{@link
         * sap.ui.core.Component.getOwnerComponentFor Component.getOwnerComponentFor}.It guarantees that the
         * returned object (if any) will be a Component.<strong>Further note</strong> that only the ID of the
         * owner is recorded. In rare cases,when the lifecycle of a ManagedObject is not bound to the lifecycle
         * of its owner,(e.g. by the means of aggregations), then the owner might have been destroyed
         * alreadywhereas the ManagedObject is still alive. So even the existence of an owner ID isnot a
         * guarantee for the existence of the corresponding owner.
         * @since 1.15.1
         * @param oObject Object to retrieve the owner ID for
         * @returns ID of the owner or <code>undefined</code>
        */
        getOwnerIdFor(oObject: sap.ui.base.ManagedObject): string;

        /**
         * Returns a service interface for the {@link sap.ui.core.service.Service Service}declared in the
         * descriptor for components (manifest.json). The declaration needsto be done in the
         * <code>sap.ui5/services</code> section as follows:<pre>{  [...]  "sap.ui5": {    "services": {     
         * "myLocalServiceAlias": {        "factoryName": "my.ServiceFactory",        ["optional": true]      }
         *    }  }  [...]}</pre>The service declaration is used to define a mapping between the localalias for
         * the service that can be used in the Component and the name ofthe service factory which will be used
         * to create a service instance.The <code>getService</code> function will look up the service factory
         * and willcreate a new instance by using the service factory function{@link
         * sap.ui.core.service.ServiceFactory#createInstance createInstance}The optional property defines that
         * the service is not mandatory and theusage will not depend on the availability of this service. When
         * requestingan optional service the <code>getService</code> function will reject butthere will be no
         * error logged in the console.When creating a new instance of the service the Component context will
         * bepassed as <code>oServiceContext</code> as follows:<pre>{  "scopeObject": this,     // the
         * Component instance  "scopeType": "component" // the stereotype of the scopeObject}</pre>The service
         * will be created only once per Component and reused in futurecalls to the <code>getService</code>
         * function.<p>This function will return a <code>Promise</code> which provides the serviceinterface
         * when resolved. If the <code>factoryName</code> could notbe found in the {@link
         * sap.ui.core.service.ServiceFactoryRegistry Service Factory Registry}or the service declaration in
         * the descriptor for components (manifest.json)is missing the Promise will reject.This is an example
         * of how the <code>getService</code> function can be
         * used:<pre>oComponent.getService("myLocalServiceAlias").then(function(oService) { 
         * oService.doSomething();}).catch(function(oError) {  jQuery.sap.log.error(oError);});</pre>
         * @since 1.37.0
         * @param sLocalServiceAlias Local service alias as defined in the manifest.json
         * @returns Promise which will be resolved with the Service interface
        */
        getService(sLocalServiceAlias: string): JQueryPromise<any>;

        /**
         * Initializes the Component instance after creation.Applications must not call this hook method
         * directly, it is called by theframework while the constructor of an Component is executed.Subclasses
         * of Component should override this hook to implement any necessaryinitialization.
        */
        init(): void;

        /**
         * The hook which gets called when the static configuration of the componenthas been changed by some
         * configuration extension.
         * @since 1.15.1
         * @param sConfigKey Error message.
        */
        onConfigChange(sConfigKey: string): void;

        /**
         * The window before unload hook. Override this method in your Component classimplementation, to handle
         * cleanup before the real unload or to prompt a questionto the user, if the component should be
         * exited.
         * @since 1.15.1
         * @returns a string if a prompt should be displayed to the user                 confirming closing the
         * Component (e.g. when the Component is not yet saved).
        */
        onWindowBeforeUnload(): string;

        /**
         * The window error hook. Override this method in your Component class implementationto listen to
         * unhandled errors.
         * @since 1.15.1
         * @param sMessage The error message.
         * @param sFile File where the error occurred
         * @param iLine Line number of the error
        */
        onWindowError(sMessage: string, sFile: string, iLine: number): void;

        /**
         * The window unload hook. Override this method in your Component classimplementation, to handle
         * cleanup of the component once the windowwill be unloaded (e.g. closed).
         * @since 1.15.1
        */
        onWindowUnload(): void;

        /**
         * Calls the function <code>fn</code> once and marks all ManagedObjectscreated during that call as
         * "owned" by this Component.Nested calls of this method are supported (e.g. inside a newly
         * created,nested component). The currently active owner Component will be rememberedbefore executing
         * <code>fn</code> and restored afterwards.
         * @since 1.25.1
         * @param fn Function to execute
         * @returns result of function <code>fn</code>
        */
        runAsOwner(fn: any): any;
      }
      /**
       * The ScrollBar control can be used for virtual scrolling of a certain area.This means: to simulate a
       * very large scrollable area when technically the area is small and the control takes care of
       * displaying the respective part only. E.g. a Table control can take care of only rendering the
       * currently visible rows and use this ScrollBar control to make the user think they actually scroll
       * through a long list.
       * @resource sap/ui/core/ScrollBar.js
      */
      export class ScrollBar extends sap.ui.core.Control {


        /**
         * Constructor for a new ScrollBar.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Attaches event handler <code>fnFunction</code> to the <code>scroll</code> event of this
         * <code>sap.ui.core.ScrollBar</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.core.ScrollBar</code> itself.Scroll event.
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.core.ScrollBar</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachScroll(oData: any, fnFunction: any, oListener?: any): sap.ui.core.ScrollBar;

        /**
         * Binds the mouse wheel scroll event of the control that has the scrollbar to the scrollbar itself.
         * @param oOwnerDomRef Dom ref of the control that uses the scrollbar
        */
        bind(oOwnerDomRef: string): void;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>scroll</code> event of this
         * <code>sap.ui.core.ScrollBar</code>.The passed function and listener object must match the ones used
         * for event registration.
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachScroll(fnFunction: any, oListener: any): sap.ui.core.ScrollBar;


        /**
         * Fires event <code>scroll</code> to attached listeners.Expects the following event
         * parameters:<ul><li><code>action</code> of type <code>sap.ui.core.ScrollBarAction</code>Actions are:
         * Click on track, button, drag of thumb, or mouse wheel click.</li><li><code>forward</code> of type
         * <code>boolean</code>Direction of scrolling: back (up) or forward
         * (down).</li><li><code>newScrollPos</code> of type <code>int</code>Current Scroll position either in
         * pixels or in steps.</li><li><code>oldScrollPos</code> of type <code>int</code>Old Scroll position -
         * can be in pixels or in steps.</li></ul>
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireScroll(mArguments: any): sap.ui.core.ScrollBar;

        /**
         * Gets current value of property <code>contentSize</code>.Size of the scrollable content (in pixels).
         * @returns Value of property <code>contentSize</code>
        */
        getContentSize(): any;

        /**
         * Returns a metadata object for class sap.ui.core.ScrollBar.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>scrollPosition</code>.Scroll position in steps or pixels.
         * @returns Value of property <code>scrollPosition</code>
        */
        getScrollPosition(): number;

        /**
         * Gets current value of property <code>size</code>.Size of the Scrollbar (in pixels).
         * @returns Value of property <code>size</code>
        */
        getSize(): any;

        /**
         * Gets current value of property <code>steps</code>.Number of steps to scroll. Used if the size of the
         * content is not known as the data is loaded dynamically.
         * @returns Value of property <code>steps</code>
        */
        getSteps(): number;

        /**
         * Gets current value of property <code>vertical</code>.Orientation. Defines if the Scrollbar is
         * vertical or horizontal.Default value is <code>true</code>.
         * @returns Value of property <code>vertical</code>
        */
        getVertical(): boolean;

        /**
         * Page Down is used to scroll one page forward.
        */
        pageDown(): void;

        /**
         * Page Up is used to scroll one page back.
        */
        pageUp(): void;

        /**
         * Sets a new value for property <code>contentSize</code>.Size of the scrollable content (in
         * pixels).When called with a value of <code>null</code> or <code>undefined</code>, the default value
         * of the property will be restored.
         * @param sContentSize New value for property <code>contentSize</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setContentSize(sContentSize: any): sap.ui.core.ScrollBar;

        /**
         * Sets a new value for property <code>scrollPosition</code>.Scroll position in steps or pixels.When
         * called with a value of <code>null</code> or <code>undefined</code>, the default value of the
         * property will be restored.
         * @param iScrollPosition New value for property <code>scrollPosition</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setScrollPosition(iScrollPosition: number): sap.ui.core.ScrollBar;

        /**
         * Sets a new value for property <code>size</code>.Size of the Scrollbar (in pixels).When called with a
         * value of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.
         * @param sSize New value for property <code>size</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setSize(sSize: any): sap.ui.core.ScrollBar;

        /**
         * Sets a new value for property <code>steps</code>.Number of steps to scroll. Used if the size of the
         * content is not known as the data is loaded dynamically.When called with a value of <code>null</code>
         * or <code>undefined</code>, the default value of the property will be restored.
         * @param iSteps New value for property <code>steps</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setSteps(iSteps: number): sap.ui.core.ScrollBar;

        /**
         * Sets a new value for property <code>vertical</code>.Orientation. Defines if the Scrollbar is
         * vertical or horizontal.When called with a value of <code>null</code> or <code>undefined</code>, the
         * default value of the property will be restored.Default value is <code>true</code>.
         * @param bVertical New value for property <code>vertical</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setVertical(bVertical: boolean): sap.ui.core.ScrollBar;

        /**
         * Unbinds the mouse wheel scroll event of the control that has the scrollbar
         * @param oOwnerDomRef Dom ref of the Control that uses the scrollbar
        */
        unbind(oOwnerDomRef: string): void;
      }
      /**
       * Contains a single key/value pair of custom data attached to an Element. See method data().
       * @resource sap/ui/core/CustomData.js
      */
      export class CustomData extends sap.ui.core.Element {


        /**
         * Constructor for a new CustomData.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);




        /**
         * Gets current value of property <code>key</code>.The key of the data in this CustomData object.When
         * the data is just stored, it can be any string, but when it is to be written to HTML (writeToDom ==
         * true) then it must also be a valid HTML attribute name (it must conform to the any type
         * and may contain no colon) to avoid collisions, it also may not start with "sap-ui". When written to
         * HTML, the key is prefixed with "data-".If any restriction is violated, a warning will be logged and
         * nothing will be written to the DOM.
         * @returns Value of property <code>key</code>
        */
        getKey(): string;

        /**
         * Returns a metadata object for class sap.ui.core.CustomData.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>value</code>.The data stored in this CustomData object.When the
         * data is just stored, it can be any JS type, but when it is to be written to HTML (writeToDom ==
         * true) then it must be a string.If this restriction is violated, a warning will be logged and nothing
         * will be written to the DOM.
         * @returns Value of property <code>value</code>
        */
        getValue(): any;

        /**
         * Gets current value of property <code>writeToDom</code>.If set to "true" and the value is of type
         * "string" and the key conforms to the documented restrictions, this custom data is written to the
         * HTML root element of the control as a "data-*" attribute.If the key is "abc" and the value is "cde",
         * the HTML will look as follows:&lt;SomeTag ... data-abc="cde" ... &gt;Thus the application can
         * provide stable attributes by data binding which can be used for styling or identification
         * purposes.ATTENTION: use carefully to not create huge attributes or a large number of them.Default
         * value is <code>false</code>.
         * @since 1.9.0
         * @returns Value of property <code>writeToDom</code>
        */
        getWriteToDom(): boolean;

        /**
         * Sets a new value for property <code>key</code>.The key of the data in this CustomData object.When
         * the data is just stored, it can be any string, but when it is to be written to HTML (writeToDom ==
         * true) then it must also be a valid HTML attribute name (it must conform to the any type
         * and may contain no colon) to avoid collisions, it also may not start with "sap-ui". When written to
         * HTML, the key is prefixed with "data-".If any restriction is violated, a warning will be logged and
         * nothing will be written to the DOM.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.
         * @param sKey New value for property <code>key</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setKey(sKey: string): sap.ui.core.CustomData;

        /**
         * Sets a new value for property <code>value</code>.The data stored in this CustomData object.When the
         * data is just stored, it can be any JS type, but when it is to be written to HTML (writeToDom ==
         * true) then it must be a string.If this restriction is violated, a warning will be logged and nothing
         * will be written to the DOM.When called with a value of <code>null</code> or <code>undefined</code>,
         * the default value of the property will be restored.
         * @param oValue New value for property <code>value</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setValue(oValue: any): sap.ui.core.CustomData;

        /**
         * Sets a new value for property <code>writeToDom</code>.If set to "true" and the value is of type
         * "string" and the key conforms to the documented restrictions, this custom data is written to the
         * HTML root element of the control as a "data-*" attribute.If the key is "abc" and the value is "cde",
         * the HTML will look as follows:&lt;SomeTag ... data-abc="cde" ... &gt;Thus the application can
         * provide stable attributes by data binding which can be used for styling or identification
         * purposes.ATTENTION: use carefully to not create huge attributes or a large number of them.When
         * called with a value of <code>null</code> or <code>undefined</code>, the default value of the
         * property will be restored.Default value is <code>false</code>.
         * @since 1.9.0
         * @param bWriteToDom New value for property <code>writeToDom</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setWriteToDom(bWriteToDom: boolean): sap.ui.core.CustomData;
      }
      /**
       * Data provides access to locale-specific data, like date formats, number formats, currencies, etc.
       * @resource sap/ui/core/LocaleData.js
      */
      export class LocaleData extends sap.ui.base.Object {


        /**
         * Creates an instance of the Data.
         * @param oLocale the locale
        */
        constructor(oLocale: sap.ui.core.Locale);




        /**
         * Returns the defined pattern for representing the calendar week number.
         * @since 1.32.0
         * @param sStyle the style of the pattern. It can only be either "wide" or "narrow".
         * @param iWeekNumber the week number
         * @returns the week number string
        */
        getCalendarWeek(sStyle: string, iWeekNumber: number): string;

        /**
         * Get combined datetime pattern with given date and and time style
         * @param sDateStyle the required style for the date part
         * @param sTimeStyle the required style for the time part
         * @param sCalendarType the type of calendar. If it's not set, it falls back to the calendar type
         * either set in configuration or calculated from locale.
         * @returns the combined datetime pattern
        */
        getCombinedDateTimePattern(sDateStyle: string, sTimeStyle: string, sCalendarType?: sap.ui.core.CalendarType): string;

        /**
         * Returns the currency code which is corresponded with the given currency symbol.
         * @since 1.27.0
         * @param sCurrencySymbol The currency symbol which needs to be converted to currency code
         * @returns The corresponded currency code defined for the given currency symbol. The given currency
         * symbol is returned if no currency code can be found by using the given currency symbol.
        */
        getCurrencyCodeBySymbol(sCurrencySymbol: string): string;

        /**
         * Returns the number of digits of the specified currency
         * @since 1.21.1
         * @param sCurrency ISO 4217 currency code
         * @returns digits of the currency
        */
        getCurrencyDigits(sCurrency: string): number;

        /**
         * Get currency format pattern
         * @param sContext the context of the currency pattern (standard or accounting)
         * @returns The pattern
        */
        getCurrencyPattern(sContext: string): string;

        /**
         * Returns the currency symbol for the specified currency, if no symbol is found the ISO 4217 currency
         * code is returned
         * @since 1.21.1
         * @param sCurrency ISO 4217 currency code
         * @returns the currency symbol
        */
        getCurrencySymbol(sCurrency: string): string;

        /**
         * Get custom datetime pattern for a given skeleton format.The format string does contain pattern
         * symbols (e.g. "yMMMd" or "Hms") and will be converted into the pattern in the usedlocale, which
         * matches the wanted symbols best. The symbols must be in canonical order, that is:Era (G), Year
         * (y/Y), Quarter (q/Q), Month (M/L), Week (w/W), Day-Of-Week (E/e/c), Day (d/D),Hour (h/H/k/K/),
         * Minute (m), Second (s), Timezone (z/Z/v/V/O/X/x)See
         * http://unicode.org/reports/tr35/tr35-dates.html#availableFormats_appendItems
         * @since 1.34
         * @param sSkeleton the wanted skeleton format for the datetime pattern
         * @param sCalendarType the type of calendar. If it's not set, it falls back to the calendar type
         * either set in configuration or calculated from locale.
         * @returns the best matching datetime pattern
        */
        getCustomDateTimePattern(sSkeleton: string, sCalendarType?: sap.ui.core.CalendarType): string;

        /**
         * Get date pattern in format "short", "medium", "long" or "full"
         * @param sStyle the required style for the date pattern
         * @param sCalendarType the type of calendar. If it's not set, it falls back to the calendar type
         * either set in configuration or calculated from locale.
         * @returns the selected date pattern
        */
        getDatePattern(sStyle: string, sCalendarType?: sap.ui.core.CalendarType): string;

        /**
         * Get datetime pattern in style "short", "medium", "long" or "full"
         * @param sStyle the required style for the datetime pattern
         * @param sCalendarType the type of calendar. If it's not set, it falls back to the calendar type
         * either set in configuration or calculated from locale.
         * @returns the selected datetime pattern
        */
        getDateTimePattern(sStyle: string, sCalendarType?: sap.ui.core.CalendarType): string;

        /**
         * Get day periods in width "narrow", "abbreviated" or "wide"
         * @param sWidth the required width for the day period names
         * @param sCalendarType the type of calendar. If it's not set, it falls back to the calendar type
         * either set in configuration or calculated from locale.
         * @returns array of day periods (AM, PM)
        */
        getDayPeriods(sWidth: string, sCalendarType?: sap.ui.core.CalendarType): any[];

        /**
         * Get standalone day periods in width "narrow", "abbreviated" or "wide"
         * @param sWidth the required width for the day period names
         * @param sCalendarType the type of calendar. If it's not set, it falls back to the calendar type
         * either set in configuration or calculated from locale.
         * @returns array of day periods (AM, PM)
        */
        getDayPeriodsStandAlone(sWidth: string, sCalendarType?: sap.ui.core.CalendarType): any[];

        /**
         * Get day names in width "narrow", "abbreviated" or "wide"
         * @param sWidth the required width for the day names
         * @param sCalendarType the type of calendar. If it's not set, it falls back to the calendar type
         * either set in configuration or calculated from locale.
         * @returns array of day names (starting with Sunday)
        */
        getDays(sWidth: string, sCalendarType?: sap.ui.core.CalendarType): any[];

        /**
         * Get stand alone day names in width "narrow", "abbreviated" or "wide"
         * @param sWidth the required width for the day names
         * @param sCalendarType the type of calendar. If it's not set, it falls back to the calendar type
         * either set in configuration or calculated from locale.
         * @returns array of day names (starting with Sunday)
        */
        getDaysStandAlone(sWidth: string, sCalendarType?: sap.ui.core.CalendarType): any[];

        /**
         * Returns the short decimal formats (like 1K, 1M....)
         * @since 1.25.0
         * @param sStyle short or long
         * @param sNumber 1000, 10000 ...
         * @param sPlural one or other (if not exists other is used)
         * @returns decimal format
        */
        getDecimalFormat(sStyle: string, sNumber: string, sPlural: string): string;

        /**
         * Get decimal format pattern
         * @returns The pattern
        */
        getDecimalPattern(): string;

        /**
         * Returns the display name for a time unit (second, minute, hour, day, week, month, year)
         * @since 1.34.0
         * @param sType Type (second, minute, hour, day, week, month, year)
         * @param sStyle @since 1.32.10, 1.34.4 the style of the pattern. The valid values are "wide", "short"
         * and "narrow"returns {string} display name
        */
        getDisplayName(sType: string, sStyle?: string): void;

        /**
         * Returns the map of era ids to era dates
         * @since 1.32.0
         * @param sCalendarType the type of calendar
         * @returns the array of eras containing objects with either an _end or _start property with a date
        */
        getEraDates(sCalendarType: sap.ui.core.CalendarType): any[];

        /**
         * Returns array of eras
         * @since 1.32.0
         * @param sWidth the style of the era name. It can be 'wide', 'abbreviated' or 'narrow'
         * @param sCalendarType the type of calendar
         * @returns the array of eras
        */
        getEras(sWidth: string, sCalendarType?: sap.ui.core.CalendarType): any[];

        /**
         * Returns the day that usually is regarded as the first dayof a week in the current locale. Days are
         * encoded as integerwhere sunday=0, monday=1 etc.All week data information in the CLDR is provides for
         * territories (countries).If the locale of this LocaleData doesn't contain country information (e.g.
         * if itcontains only a language), then the "likelySubtag" information of the CLDRis taken into account
         * to guess the "most likely" territory for the locale.
         * @returns first day of week
        */
        getFirstDayOfWeek(): number;

        /**
         * Returns the interval format with the given Id (see CLDR documentation for valid Ids)or the fallback
         * format if no interval format with that Id is known.The empty Id ("") might be used to retrieve the
         * interval format fallback.
         * @since 1.17.0
         * @param sId Id of the interval format, e.g. "d-d"
         * @param sCalendarType the type of calendar. If it's not set, it falls back to the calendar type
         * either set in configuration or calculated from locale.
         * @returns interval format string with placeholders {0} and {1}
        */
        getIntervalPattern(sId: string, sCalendarType?: sap.ui.core.CalendarType): string;

        /**
         * Get locale specific language names
         * @returns map of locale specific language names
        */
        getLanguages(): any;

        /**
         * Returns a metadata object for class sap.ui.core.LocaleData.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Get month names in width "narrow", "abbreviated" or "wide"
         * @param sWidth the required width for the month names
         * @param sCalendarType the type of calendar. If it's not set, it falls back to the calendar type
         * either set in configuration or calculated from locale.
         * @returns array of month names (starting with January)
        */
        getMonths(sWidth: string, sCalendarType?: sap.ui.core.CalendarType): any[];

        /**
         * Get stand alone month names in width "narrow", "abbreviated" or "wide"
         * @param sWidth the required width for the month names
         * @param sCalendarType the type of calendar. If it's not set, it falls back to the calendar type
         * either set in configuration or calculated from locale.
         * @returns array of month names (starting with January)
        */
        getMonthsStandAlone(sWidth: string, sCalendarType?: sap.ui.core.CalendarType): any[];

        /**
         * Get number symbol "decimal", "group", "plusSign", "minusSign", "percentSign"
         * @param sType the required type of symbol
         * @returns the selected number symbol
        */
        getNumberSymbol(sType: string): string;

        /**
         * Get orientation (left-to-right or right-to-left)
         * @returns character orientation for this locale
        */
        getOrientation(): string;

        /**
         * Get percent format pattern
         * @returns The pattern
        */
        getPercentPattern(): string;

        /**
         * Returns the preferred calendar type for the current locale which exists in {@link
         * sap.ui.core.CalendarType}returns {sap.ui.core.CalendarType} the preferred calendar type
         * @since 1.28.6
        */
        getPreferredCalendarType(): void;

        /**
         * Returns the preferred hour pattern symbol (h for 12, H for 24 hours) for the current localereturns
         * {string} the preferred hour symbol
         * @since 1.34
        */
        getPreferredHourSymbol(): void;

        /**
         * Get quarter names in width "narrow", "abbreviated" or "wide"
         * @param sWidth the required width for the quarter names
         * @param sCalendarType the type of calendar. If it's not set, it falls back to the calendar type
         * either set in configuration or calculated from locale.
         * @returns array of quarters
        */
        getQuarters(sWidth: string, sCalendarType?: sap.ui.core.CalendarType): any[];

        /**
         * Get stand alone quarter names in width "narrow", "abbreviated" or "wide"
         * @param sWidth the required width for the quarter names
         * @param sCalendarType the type of calendar. If it's not set, it falls back to the calendar type
         * either set in configuration or calculated from locale.
         * @returns array of quarters
        */
        getQuartersStandAlone(sWidth: string, sCalendarType?: sap.ui.core.CalendarType): any[];

        /**
         * Returns the relative day resource pattern (like "Today", "Yesterday", "{0} days ago") based on the
         * givendifference of days (0 means today, 1 means tommorrow, -1 means yesterday, ...).
         * @since 1.25.0
         * @param iDiff the difference in days
         * @param sStyle @since 1.32.10, 1.34.4 the style of the pattern. The valid values are "wide", "short"
         * and "narrow"
         * @returns the relative day resource pattern
        */
        getRelativeDay(iDiff: number, sStyle?: string): string;

        /**
         * Returns the relative resource pattern with unit 'hour' (like "in {0} hour(s)", "{0} hour(s) ago"
         * under locale 'en') based on the givendifference value (positive value means in the future and
         * negative value means in the past).There's no pattern defined for 0 difference and the function
         * returns null if 0 is given. In the 0 difference case, you can use the getRelativeMinute or
         * getRelativeSecondfunction to format the difference using unit 'minute' or 'second'.
         * @since 1.31.0
         * @param iDiff the difference in hours
         * @param sStyle @since 1.32.10, 1.34.4 the style of the pattern. The valid values are "wide", "short"
         * and "narrow"
         * @returns the relative resource pattern in unit 'hour'. The method returns null if 0 is given as
         * parameter.
        */
        getRelativeHour(iDiff: number, sStyle?: string): string | any;

        /**
         * Returns the relative resource pattern with unit 'minute' (like "in {0} minute(s)", "{0} minute(s)
         * ago" under locale 'en') based on the givendifference value (positive value means in the future and
         * negative value means in the past).There's no pattern defined for 0 difference and the function
         * returns null if 0 is given. In the 0 difference case, you can use the getRelativeSecondfunction to
         * format the difference using unit 'second'.
         * @since 1.31.0
         * @param iDiff the difference in minutes
         * @param sStyle @since 1.32.10, 1.34.4 the style of the pattern. The valid values are "wide", "short"
         * and "narrow"
         * @returns the relative resource pattern in unit 'minute'. The method returns null if 0 is given as
         * parameter.
        */
        getRelativeMinute(iDiff: number, sStyle?: string): string | any;

        /**
         * Returns the relative month resource pattern (like "This month", "Last month", "{0} months ago")
         * based on the givendifference of months (0 means this month, 1 means next month, -1 means last month,
         * ...).
         * @since 1.25.0
         * @param iDiff the difference in months
         * @param sStyle @since 1.32.10, 1.34.4 the style of the pattern. The valid values are "wide", "short"
         * and "narrow"
         * @returns the relative month resource pattern
        */
        getRelativeMonth(iDiff: number, sStyle?: string): string;

        /**
         * Returns the relative format pattern with given scale (year, month, week, ...) and difference value
         * @since 1.34
         * @param sScale the scale the relative pattern is needed for
         * @param iDiff the difference in the given scale unit
         * @param bFuture whether a future or past pattern should be used
         * @param sStyle @since 1.32.10, 1.34.4 the style of the pattern. The valid values are "wide", "short"
         * and "narrow"
         * @returns the relative format pattern
        */
        getRelativePattern(sScale: string, iDiff: number, bFuture?: boolean, sStyle?: string): string;

        /**
         * Returns relative time patterns for the given scales as an array of objects containing scale, value
         * and pattern.The array may contain the following values: "year", "month", "week", "day", "hour",
         * "minute" and "second". Ifno scales are given, patterns for all available scales will be returned.The
         * return array will contain objects looking like:{    scale: "minute",    sign: 1,    pattern: "in {0}
         * minutes"}
         * @since 1.34
         * @param aScales The scales for which the available patterns should be returned
         * @param sStyle @since 1.32.10, 1.34.4 The style of the scale patterns. The valid values are "wide",
         * "short" and "narrow".
         * @returns An array of all relative time patterns
        */
        getRelativePatterns(aScales: string[], sStyle?: string): any[];

        /**
         * Returns the relative resource pattern with unit 'second' (like now, "in {0} seconds", "{0} seconds
         * ago" under locale 'en') based on the givendifference value (0 means now, positive value means in the
         * future and negative value means in the past).
         * @since 1.31.0
         * @param iDiff the difference in seconds
         * @param sStyle @since 1.32.10, 1.34.4 the style of the pattern. The valid values are "wide", "short"
         * and "narrow"
         * @returns the relative resource pattern in unit 'second'
        */
        getRelativeSecond(iDiff: number, sStyle?: string): string;

        /**
         * Returns the relative week resource pattern (like "This week", "Last week", "{0} weeks ago") based on
         * the givendifference of weeks (0 means this week, 1 means next week, -1 means last week, ...).
         * @since 1.31.0
         * @param iDiff the difference in weeks
         * @param sStyle @since 1.32.10, 1.34.4 the style of the pattern. The valid values are "wide", "short"
         * and "narrow"
         * @returns the relative week resource pattern
        */
        getRelativeWeek(iDiff: number, sStyle?: string): string;

        /**
         * Returns the relative year resource pattern (like "This year", "Last year", "{0} year ago") based on
         * the givendifference of years (0 means this year, 1 means next year, -1 means last year, ...).
         * @since 1.25.0
         * @param iDiff the difference in years
         * @param sStyle @since 1.32.10, 1.34.4 the style of the pattern. The valid values are "wide", "short"
         * and "narrow"
         * @returns the relative year resource pattern
        */
        getRelativeYear(iDiff: number, sStyle?: string): string;

        /**
         * Get locale specific script names
         * @returns map of locale specific script names
        */
        getScripts(): any;

        /**
         * Get locale specific territory names
         * @returns map of locale specific territory names
        */
        getTerritories(): any;

        /**
         * Get time pattern in style "short", "medium", "long" or "full"
         * @param sStyle the required style for the date pattern
         * @param sCalendarType the type of calendar. If it's not set, it falls back to the calendar type
         * either set in configuration or calculated from locale.
         * @returns the selected time pattern
        */
        getTimePattern(sStyle: string, sCalendarType?: sap.ui.core.CalendarType): string;

        /**
         * Returns the last day of a weekend for the given locale.Days are encoded in the same way as for
         * {@link #getFirstDayOfWeek}.All week data information in the CLDR is provides for territories
         * (countries).If the locale of this LocaleData doesn't contain country information (e.g. if itcontains
         * only a language), then the "likelySubtag" information of the CLDRis taken into account to guess the
         * "most likely" territory for the locale.
         * @returns last day of weekend
        */
        getWeekendEnd(): number;

        /**
         * Returns the first day of a weekend for the given locale.Days are encoded in the same way as for
         * {@link #getFirstDayOfWeek}.All week data information in the CLDR is provides for territories
         * (countries).If the locale of this LocaleData doesn't contain country information (e.g. if itcontains
         * only a language), then the "likelySubtag" information of the CLDRis taken into account to guess the
         * "most likely" territory for the locale.
         * @returns first day of weekend
        */
        getWeekendStart(): number;
      }
      /**
       * A layout data base type.
       * @resource sap/ui/core/LayoutData.js
      */
      export class LayoutData extends sap.ui.core.Element {


        /**
         * Constructor for a new LayoutData.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);




        /**
         * Returns a metadata object for class sap.ui.core.LayoutData.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;
      }
      /**
       * Abstract class that can be extended in order to implement any extended tooltip. For example,
       * RichTooltip Control is based on it. It provides the opening/closing behavior and the main "text"
       * property.
       * @resource sap/ui/core/TooltipBase.js
      */
      export class TooltipBase extends sap.ui.core.Control {


        /**
         * Constructor for a new TooltipBase.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Attaches event handler <code>fnFunction</code> to the <code>closed</code> event of this
         * <code>sap.ui.core.TooltipBase</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.core.TooltipBase</code> itself.This event is fired when the Tooltip has been
         * closed
         * @since 1.11.0
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.core.TooltipBase</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachClosed(oData: any, fnFunction: any, oListener?: any): sap.ui.core.TooltipBase;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>closed</code> event of this
         * <code>sap.ui.core.TooltipBase</code>.The passed function and listener object must match the ones
         * used for event registration.
         * @since 1.11.0
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachClosed(fnFunction: any, oListener: any): sap.ui.core.TooltipBase;


        /**
         * Fires event <code>closed</code> to attached listeners.
         * @since 1.11.0
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireClosed(mArguments: any): sap.ui.core.TooltipBase;

        /**
         * Gets current value of property <code>atPosition</code>.Optional. At position defines which position
         * on the target control to align the positioned tooltip.Default value is <code>begin bottom</code>.
         * @returns Value of property <code>atPosition</code>
        */
        getAtPosition(): any;

        /**
         * Gets current value of property <code>closeDelay</code>.Closing delay of the tooltip in
         * millisecondsDefault value is <code>100</code>.
         * @returns Value of property <code>closeDelay</code>
        */
        getCloseDelay(): number;

        /**
         * Gets current value of property <code>closeDuration</code>.Optional. Close Duration in
         * milliseconds.Default value is <code>200</code>.
         * @returns Value of property <code>closeDuration</code>
        */
        getCloseDuration(): number;

        /**
         * Gets current value of property <code>collision</code>.Optional. Collision - when the positioned
         * element overflows the window in some direction, move it to an alternative position.Default value is
         * <code>flip</code>.
         * @returns Value of property <code>collision</code>
        */
        getCollision(): any;

        /**
         * Returns a metadata object for class sap.ui.core.TooltipBase.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>myPosition</code>.Optional. My position defines which position
         * on the extended tooltip being positioned to align with the target control.Default value is
         * <code>begin top</code>.
         * @returns Value of property <code>myPosition</code>
        */
        getMyPosition(): any;

        /**
         * Gets current value of property <code>offset</code>.Optional. Offset adds these left-top values to
         * the calculated position.Example: "10 3".Default value is <code>10 3</code>.
         * @returns Value of property <code>offset</code>
        */
        getOffset(): string;

        /**
         * Gets current value of property <code>openDelay</code>.Opening delay of the tooltip in
         * millisecondsDefault value is <code>500</code>.
         * @returns Value of property <code>openDelay</code>
        */
        getOpenDelay(): number;

        /**
         * Gets current value of property <code>openDuration</code>.Optional. Open Duration in
         * milliseconds.Default value is <code>200</code>.
         * @returns Value of property <code>openDuration</code>
        */
        getOpenDuration(): number;

        /**
         * Gets current value of property <code>text</code>.The text that is shown in the tooltip that extends
         * the TooltipBase class, for example in RichTooltip.Default value is <code></code>.
         * @returns Value of property <code>text</code>
        */
        getText(): string;

        /**
         * Sets a new value for property <code>atPosition</code>.Optional. At position defines which position
         * on the target control to align the positioned tooltip.When called with a value of <code>null</code>
         * or <code>undefined</code>, the default value of the property will be restored.Default value is
         * <code>begin bottom</code>.
         * @param sAtPosition New value for property <code>atPosition</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setAtPosition(sAtPosition: any): sap.ui.core.TooltipBase;

        /**
         * Sets a new value for property <code>closeDelay</code>.Closing delay of the tooltip in
         * millisecondsWhen called with a value of <code>null</code> or <code>undefined</code>, the default
         * value of the property will be restored.Default value is <code>100</code>.
         * @param iCloseDelay New value for property <code>closeDelay</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setCloseDelay(iCloseDelay: number): sap.ui.core.TooltipBase;

        /**
         * Sets a new value for property <code>closeDuration</code>.Optional. Close Duration in
         * milliseconds.When called with a value of <code>null</code> or <code>undefined</code>, the default
         * value of the property will be restored.Default value is <code>200</code>.
         * @param iCloseDuration New value for property <code>closeDuration</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setCloseDuration(iCloseDuration: number): sap.ui.core.TooltipBase;

        /**
         * Sets a new value for property <code>collision</code>.Optional. Collision - when the positioned
         * element overflows the window in some direction, move it to an alternative position.When called with
         * a value of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>flip</code>.
         * @param sCollision New value for property <code>collision</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setCollision(sCollision: any): sap.ui.core.TooltipBase;

        /**
         * Sets a new value for property <code>myPosition</code>.Optional. My position defines which position
         * on the extended tooltip being positioned to align with the target control.When called with a value
         * of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>begin top</code>.
         * @param sMyPosition New value for property <code>myPosition</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setMyPosition(sMyPosition: any): sap.ui.core.TooltipBase;

        /**
         * Sets a new value for property <code>offset</code>.Optional. Offset adds these left-top values to the
         * calculated position.Example: "10 3".When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.Default value is <code>10
         * 3</code>.
         * @param sOffset New value for property <code>offset</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setOffset(sOffset: string): sap.ui.core.TooltipBase;

        /**
         * Sets a new value for property <code>openDelay</code>.Opening delay of the tooltip in
         * millisecondsWhen called with a value of <code>null</code> or <code>undefined</code>, the default
         * value of the property will be restored.Default value is <code>500</code>.
         * @param iOpenDelay New value for property <code>openDelay</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setOpenDelay(iOpenDelay: number): sap.ui.core.TooltipBase;

        /**
         * Sets a new value for property <code>openDuration</code>.Optional. Open Duration in milliseconds.When
         * called with a value of <code>null</code> or <code>undefined</code>, the default value of the
         * property will be restored.Default value is <code>200</code>.
         * @param iOpenDuration New value for property <code>openDuration</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setOpenDuration(iOpenDuration: number): sap.ui.core.TooltipBase;

        /**
         * Sets a new value for property <code>text</code>.The text that is shown in the tooltip that extends
         * the TooltipBase class, for example in RichTooltip.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.Default value is
         * <code></code>.
         * @param sText New value for property <code>text</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setText(sText: string): sap.ui.core.TooltipBase;
      }
      /**
       * Creates and initializes a new UIComponent with the given <code>sId</code> andsettings.The set of
       * allowed entries in the <code>mSettings</code> object depends onthe concrete subclass and is
       * described there. See {@link sap.ui.core.Component}for a general description of this argument.
       * @resource sap/ui/core/UIComponent.js
      */
      export abstract class UIComponent extends sap.ui.core.Component {


        /**
         * Base Class for UIComponent.If you are extending an UIComponent make sure you read the {@link
         * #.extend} documentation since the metadata is special.Accepts an object literal
         * <code>mSettings</code> that defines initialproperty values, aggregated and associated objects as
         * well as event handlers.See {@link sap.ui.base.ManagedObject#constructor} for a general description
         * of the syntax of the settings object.
         * @param sId Optional ID for the new control; generated automatically if           no non-empty ID is
         * given Note: this can be omitted, no matter           whether <code>mSettings</code> will be given or
         * not!
         * @param mSettings optional map/JSON-object with initial settings for the           new component
         * instance
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Returns an element by its ID in the context of the component.
         * @param sId Component local ID of the element
         * @returns element by its ID or <code>undefined</code>
        */
        byId(sId: string): sap.ui.core.Element;

        /**
         * The method to create the content (UI Control Tree) of the Component.This method has to be
         * overwritten in the implementation of the componentif the root view is not declared in the component
         * metadata.
        */
        createContent(): void;

        /**
         * Convert the given component local element ID to a globally unique IDby prefixing it with the
         * component ID.
         * @param sId Component local ID of the element
         * @returns prefixed id
        */
        createId(sId: string): string;


        /**
         * A method to be implemented by UIComponents, returning the flag whether to prefixthe IDs of controls
         * automatically or not if the controls are created insidethe {@link
         * sap.ui.core.UIComponent#createContent} function. By default thisfeature is not activated.You can
         * overwrite this function and return <code>true</code> to activate the automaticprefixing. In addition
         * the default behavior can be configured in the manifestby specifying the entry
         * <code>sap.ui5/autoPrefixId</code>.
         * @since 1.15.1
         * @returns true, if the Controls IDs should be prefixed automatically
        */
        getAutoPrefixId(): boolean;

        /**
        */
        getEventingParent(): sap.ui.base.EventProvider;

        /**
         * Returns the local ID of an element by removing the component ID prefix or<code>null</code> if the ID
         * does not contain a prefix.
         * @since 1.39.0
         * @param sId Prefixed ID
         * @returns ID without prefix or <code>null</code>
        */
        getLocalId(sId: string): string;

        /**
         * Returns a metadata object for class sap.ui.core.UIComponent.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Returns the reference to the router instance which has been created bythe UIComponent once the
         * routes in the routing metadata has been defined.
         * @since 1.16.1
         * @returns the router instance
        */
        getRouter(): sap.m.routing.Router;

        /**
         * Returns the reference to the router instance. The passed controller or viewhas to be created in the
         * context of a UIComponent to return the routerinstance. Otherwise this function will return
         * undefined.You may define the routerClass property in the config section of the routing to make the
         * Component create your router extension.Example:routing: {	config: {		routerClass :
         * myAppNamespace.MyRouterClass		...}...
         * @since 1.16.1
         * @param oControllerOrView either a view or controller
         * @returns the router instance
        */
        getRouterFor(oControllerOrView: sap.ui.core.mvc.View | sap.ui.core.mvc.Controller): sap.m.routing.Router;

        /**
         * Returns the reference to the Targets instance which has been created bythe UIComponent once the
         * targets in the routing metadata has been defined.If routes have been defined, it will be the Targets
         * instance created and used by the router.
         * @since 1.28
         * @returns the targets instance
        */
        getTargets(): sap.ui.core.routing.Targets;

        /**
         * Returns the reference to the UIArea of the container.
         * @returns reference to the UIArea of the container
        */
        getUIArea(): sap.ui.core.UIArea;

        /**
         * Initializes the Component instance after creation.Applications must not call this hook method
         * directly, it is called by theframework while the constructor of a Component is executed.Subclasses
         * of Component should override this hook to implement any necessaryinitialization. <b>When overriding
         * this function make sure to invoke theinit function of the UIComponent as well!</b>
        */
        init(): void;

        /**
         * Function is called when the rendering of the ComponentContainer is completed.Applications must not
         * call this hook method directly, it is called from ComponentContainer.Subclasses of UIComponent
         * override this hook to implement any necessary actions after the rendering.
        */
        onAfterRendering(): void;

        /**
         * Function is called when the rendering of the ComponentContainer is started.Applications must not
         * call this hook method directly, it is called from ComponentContainer.Subclasses of UIComponent
         * override this hook to implement any necessary actions before the rendering.
        */
        onBeforeRendering(): void;

        /**
         * Renders the the root control of the UIComponent.
         * @param oRenderManager a RenderManager instance
        */
        render(oRenderManager: sap.ui.core.RenderManager): void;

        /**
         * Sets the reference to the ComponentContainer - later required for thedetermination of the UIArea for
         * the UIComponent.
         * @param oContainer reference to a ComponentContainer
         * @returns reference to this instance to allow method chaining
        */
        setContainer(oContainer: sap.ui.core.ComponentContainer): sap.ui.core.UIComponent;
      }
      /**
       * An item that provides a visual separation. It borrows all its methods from the classes
       * sap.ui.core.Item, sap.ui.core.Element,sap.ui.base.EventProvider, and sap.ui.base.Object.
       * @resource sap/ui/core/SeparatorItem.js
      */
      export class SeparatorItem extends sap.ui.core.Item {


        /**
         * Constructor for a new SeparatorItem.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);




        /**
         * Returns a metadata object for class sap.ui.core.SeparatorItem.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;
      }
      /**
       * An InvisibleText is used to bring hidden texts to the UI for screen reader support. The hidden text
       * can e.g. be referencedin the ariaLabelledBy or ariaDescribedBy associations of other controls.The
       * inherited properties busy, busyIndicatorDelay and visible and the aggregation tooltip is not
       * supported by this control.
       * @resource sap/ui/core/InvisibleText.js
      */
      export class InvisibleText extends sap.ui.core.Control {


        /**
         * Constructor for a new InvisibleText.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);




        /**
         * Returns a metadata object for class sap.ui.core.InvisibleText.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>text</code>.The text of the InvisibleText.Default value is
         * <code></code>.
         * @returns Value of property <code>text</code>
        */
        getText(): string;

        /**
         * @returns Returns <code>this</code> to allow method chaining
        */
        setBusy(): any;

        /**
         * @returns Returns <code>this</code> to allow method chaining
        */
        setBusyIndicatorDelay(): any;

        /**
         * Sets a new value for property <code>text</code>.The text of the InvisibleText.When called with a
         * value of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code></code>.
         * @param sText New value for property <code>text</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setText(sText: string): sap.ui.core.InvisibleText;

        /**
         * @returns Returns <code>this</code> to allow method chaining
        */
        setTooltip(): any;

        /**
         * @returns Returns <code>this</code> to allow method chaining
        */
        setVisible(): any;

        /**
         * Adds <code>this</code> control into the static, hidden area UI area container.
         * @returns Returns <code>this</code> to allow method chaining
        */
        toStatic(): any;
      }
      /**
       * RenderManager that will take care for rendering Controls.The RenderManager will be available from
       * the sap.ui.core.Core instance (available via <code>sap.ui.getCore()</code>).<br/>Itcan be used to
       * render Controls and Control-Trees.The convention for renderers belonging to some controls is the
       * following:<ul><li>for a Control e.g. <code>sap.ui.controls.InputField</code> there shall be
       * </li><li>a renderer named <code>sap.ui.controls.InputFieldRenderer</code></li><ul>
       * @resource sap/ui/core/RenderManager.js
      */
      export class RenderManager extends sap.ui.base.Object {


        /**
         * Creates an instance of the RenderManager.
        */
        constructor();



        /**
         * Adds a class to the class collection if the name is not empty or null.The class collection is
         * flushed if it is written to the buffer using {@link #writeClasses}
         * @param sName name of the class to be added; null values are ignored
         * @returns this render manager instance to allow chaining
        */
        addClass(sName: string): sap.ui.core.RenderManager;

        /**
         * Adds a style property to the style collection if the value is not empty or nullThe style collection
         * is flushed if it is written to the buffer using {@link #writeStyle}
         * @param sName name of the CSS property to write
         * @param value value to write
         * @returns this render manager instance to allow chaining
        */
        addStyle(sName: string, value: string | number | number): sap.ui.core.RenderManager;

        /**
         * Cleans up the rendering state of the given control with rendering it.A control is responsible for
         * the rendering of all its child controls.But in some cases it makes sense that a control does not
         * render all itschildren based on a filter condition. For example a Carousel control only rendersthe
         * current visible parts (and maybe some parts before and after the visible area)for performance
         * reasons.If a child was rendered but should not be rendered anymore because the filter conditiondoes
         * not apply anymore this child must be cleaned up correctly (e.g deregistering eventhandlers, ...).The
         * following example shows how renderControl and cleanupControlWithoutRendering shouldbe used:render =
         * function(rm, ctrl){  //...  var aAggregatedControls = //...  for(var i=0;
         * i<aAgrregatedControls.length; i++){  	if(//... some filter expression){       
         * rm.renderControl(aAggregatedControls[i]);     }else{       
         * rm.cleanupControlWithoutRendering(aAggregatedControls[i]);     }  }  //...}Note:The method does not
         * remove DOM of the given control. The callee of this method has to take over theresponsibility to
         * cleanup the DOM of the control afterwards.For parents which are rendered with the normal mechanism
         * as shown in the example above this requirementis fulfilled, because the control is not added to the
         * rendering buffer (renderControl is not called) andthe DOM is replaced when the rendering cycle is
         * finalized.
         * @since 1.22.9
         * @param oControl the control that should be cleaned up
        */
        cleanupControlWithoutRendering(oControl: sap.ui.core.Control): void;

        /**
         * Creates the ID to be used for the invisible Placeholder DOM element.This method can be used to get
         * direct access to the placeholder DOM element.Also statically available as
         * RenderManager.createInvisiblePlaceholderId()
         * @param oElement The Element instance for which to create the placeholder ID
         * @returns The ID used for the invisible Placeholder of this element
        */
        createInvisiblePlaceholderId(oElement: sap.ui.core.Element): string;

        /**
         * Cleans up the resources associated with this instance.After the instance has been destroyed, it must
         * not be used anymore.Applications should call this function if they don't need the instance any
         * longer.
        */
        destroy(bSuppressInvalidate: boolean): void;


        /**
         * Searches "to-be-preserved" nodes for the given control id.
         * @param sId control id to search content for.
         * @returns a jQuery collection representing the found content
        */
        findPreservedContent(sId: string): typeof jQuery;

        /**
         * Renders the content of the rendering buffer into the provided DOMNode.This function must not be
         * called within control renderers.Usage:<pre>// Create a new instance of the RenderManagervar rm =
         * sap.ui.getCore().createRenderManager();// Use the writer API to fill the
         * buffersrm.write(...);rm.renderControl(oControl);rm.write(...);...// Finally flush the buffer into
         * the provided DOM node (The current content is removed)rm.flush(oDomNode);// If the instance is not
         * needed anymore, destroy itrm.destroy();</pre>
         * @param oTargetDomNode The node in the dom where the buffer should be flushed into.
         * @param bDoNotPreserve flag, whether to not preserve (true) the content or to preserve it (false).
         * @param vInsert flag, whether to append (true) or replace (false) the buffer of the target dom node
         * or to insert at a certain position (int)
        */
        flush(oTargetDomNode: sap.ui.core.Element, bDoNotPreserve: boolean, vInsert: boolean | number): void;

        /**
         * Returns the configuration objectShortcut for <code>sap.ui.getCore().getConfiguration()</code>
         * @returns the configuration object
        */
        getConfiguration(): sap.ui.core.Configuration;

        /**
         * Renders the given {@link sap.ui.core.Control} and finally returnsthe content of the rendering
         * buffer.Ensures the buffer is restored to the state before calling this method.
         * @param oControl the Control whose HTML should be returned.
         * @returns the resulting HTML of the provided control
        */
        getHTML(oControl: sap.ui.core.Control): string;

        /**
         * Returns a metadata object for class sap.ui.core.RenderManager.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Returns the hidden area reference belonging to this window instance.
         * @returns the hidden area reference belonging to this core instance.
        */
        getPreserveAreaRef(): sap.ui.core.Element;

        /**
         * Returns the renderer class for a given control instance
         * @param oControl the control that should be rendered
        */
        getRenderer(oControl: sap.ui.core.Control): void;

        /**
         * Returns the renderer class for a given control instance
         * @param oControl the control that should be rendered
         * @returns the renderer class for a given control instance
        */
        getRenderer(oControl: sap.ui.core.Control): any;

        /**
         * Collects descendants of the given root node that need to be preserved before the root nodeis wiped
         * out. The "to-be-preserved" nodes are moved to a special, hidden 'preserve' area.A node is declared
         * "to-be-preserved" when it has the <code>data-sap-ui-preserve</code>attribute set. When the optional
         * parameter <code>bPreserveNodesWithId</code> is set to true,then nodes with an id are preserved as
         * well and their <code>data-sap-ui-preserve</code> attributeis set automatically. This option is used
         * by UIAreas when they render for the first time andsimplifies the handling of predefined HTML content
         * in a web page.The "to-be-preserved" nodes are searched with a depth first search and moved to the
         * 'preserve'area in the order that they are found. So for direct siblings the order should be stable.
         * @param oRootNode to search for "to-be-preserved" nodes
         * @param bPreserveRoot whether to preserve the root itself
         * @param bPreserveNodesWithId whether to preserve nodes with an id as well
        */
        preserveContent(oRootNode: sap.ui.core.Element, bPreserveRoot?: boolean, bPreserveNodesWithId?: boolean): void;

        /**
         * Renders the given control to the provided DOMNode.If the control is already rendered in the provided
         * DOMNode the DOM of the control is replaced. If the controlis already rendered somewhere else the
         * current DOM of the control is removed and the new DOM is appendedto the provided DOMNode.This
         * function must not be called within control renderers.
         * @param oControl the Control that should be rendered.
         * @param oTargetDomNode The node in the DOM where the result of the rendering should be inserted.
        */
        render(oControl: sap.ui.core.Control, oTargetDomNode: sap.ui.core.Element): void;

        /**
         * Turns the given control into its HTML representation and appends it to therendering buffer.If the
         * given control is undefined or null, then nothing is rendered.
         * @param oControl the control that should be rendered
         * @returns this render manager instance to allow chaining
        */
        renderControl(oControl: sap.ui.core.Control): sap.ui.core.RenderManager;

        /**
         * @param sKey undefined
        */
        translate(sKey: string): void;

        /**
         * Write the given texts to the buffer
         * @param sText (can be a number too)
         * @returns this render manager instance to allow chaining
        */
        write(sText: string | number): sap.ui.core.RenderManager;

        /**
         * @returns this render manager instance to allow chaining
        */
        writeAcceleratorKey(): sap.ui.core.RenderManager;

        /**
         * Writes the accessibility state (see WAI-ARIA specification) of the provided element into the
         * HTMLbased on the element's properties and associations.The ARIA properties are only written when the
         * accessibility feature is activated in the UI5 configuration.The following properties/values to ARIA
         * attribute mappings are done (if the element does have such properties):<code>editable===false</code>
         * => <code>aria-readonly="true"</code><code>enabled===false</code> =>
         * <code>aria-disabled="true"</code><code>visible===false</code> =>
         * <code>aria-hidden="true"</code><code>required===true</code> =>
         * <code>aria-required="true"</code><code>selected===true</code> =>
         * <code>aria-selected="true"</code><code>checked===true</code> => <code>aria-checked="true"</code>In
         * case of the required attribute also the Label controls which referencing the given element in their
         * 'for' relationare taken into account to compute the <code>aria-required</code>
         * attribute.Additionally the association <code>ariaDescribedBy</code> and <code>ariaLabelledBy</code>
         * are used to writethe id lists of the ARIA attributes <code>aria-describedby</code> and
         * <code>aria-labelledby</code>.Label controls which referencing the given element in their 'for'
         * relation are automatically added to the<code>aria-labelledby</code> attributes.Note: This function
         * is only a heuristic of a control property to ARIA attribute mapping. Control developershave to check
         * whether it fullfills their requirements. In case of problems (for example the RadioButton has
         * a<code>selected</code> property but must provide an <code>aria-checked</code> attribute) the
         * auto-generatedresult of this function can be influenced via the parameter <code>mProps</code> as
         * described below.The parameter <code>mProps</code> can be used to either provide additional
         * attributes which should be added and/orto avoid the automatic generation of single ARIA attributes.
         * The 'aria-' prefix will be prepended automatically to the keys(Exception: Attribute 'role' does not
         * get the prefix 'aria-').Examples:<code>{hidden : true}</code> results in
         * <code>aria-hidden="true"</code> independent of the precense or absence ofthe visibility
         * property.<code>{hidden : null}</code> ensures that no <code>aria-hidden</code> attribute is written
         * independent of the precenseor absence of the visibility property.The function behaves in the same
         * way for the associations <code>ariaDescribedBy</code> and <code>ariaLabelledBy</code>.To append
         * additional values to the auto-generated <code>aria-describedby</code> and
         * <code>aria-labelledby</code> attributesthe following format can be used:<code>{describedby : {value:
         * "id1 id2", append: true}}</code> => <code>aria-describedby="ida idb id1 id2"</code> (assuming that
         * "ida idb"is the auto-generated part based on the association <code>ariaDescribedBy</code>).
         * @param oElement the element whose accessibility state should be rendered
         * @param mProps a map of properties that should be added additionally or changed.
         * @returns this render manager instance to allow chaining
        */
        writeAccessibilityState(oElement: sap.ui.core.Element, mProps?: any): sap.ui.core.RenderManager;

        /**
         * Writes the attribute and its value into the HTML
         * @param sName the name of the attribute
         * @param value the value of the attribute
         * @returns this render manager instance to allow chaining
        */
        writeAttribute(sName: string, value: string | number | boolean): sap.ui.core.RenderManager;

        /**
         * Writes the attribute and its value into the HTMLThe value is properly escaped to avoid XSS attacks.
         * @param sName the name of the attribute
         * @param vValue the value of the attribute
         * @returns this render manager instance to allow chaining
        */
        writeAttributeEscaped(sName: string, vValue: any): sap.ui.core.RenderManager;

        /**
         * Writes and flushes the class collection (all CSS classes added by "addClass()" since the last
         * flush).Also writes the custom style classes added by the application with "addStyleClass(...)".
         * Custom classes areadded by default from the currently rendered control. If an oElement is given,
         * this Element's custom styleclasses are added instead. If oElement === false, no custom style classes
         * are added.
         * @param oElement an Element from which to add custom style classes (instead of adding from the
         * control itself)
         * @returns this render manager instance to allow chaining
        */
        writeClasses(oElement: sap.ui.core.Element | boolean): sap.ui.core.RenderManager;

        /**
         * Writes the controls data into the HTML.Control Data consists at least of the id of a control
         * @param oControl the control whose identifying information should be written to the buffer
         * @returns this render manager instance to allow chaining
        */
        writeControlData(oControl: sap.ui.core.Control): sap.ui.core.RenderManager;

        /**
         * Writes the elements data into the HTML.Element Data consists at least of the id of a element
         * @param oElement the element whose identifying information should be written to the buffer
         * @returns this render manager instance to allow chaining
        */
        writeElementData(oElement: sap.ui.core.Element): sap.ui.core.RenderManager;

        /**
         * Escape text for HTML and write it to the buffer
         * @param sText undefined
         * @param bLineBreaks Whether to convert linebreaks into <br> tags
         * @returns this render manager instance to allow chaining
        */
        writeEscaped(sText: string, bLineBreaks: boolean): sap.ui.core.RenderManager;

        /**
         * Writes necessary invisible control/element placeholder data into the HTML.Controls should only use
         * this method if they can't live with the standard 'visible=false' implementation of the RenderManager
         * whichrenders dummy HTMLSpanElement for better re-rendering performance. Even though HTML5 error
         * tolerance accepts this for most of the cases andthese dummy elements are not in the render tree of
         * the Browser, controls may need to generate a valid and semantic HTML output when therendered
         * HTMLSpanElement is not an allowed element(e.g. &lt;span&gt; element within the &lt;tr&gt; or
         * &lt;li&gt; group).The caller needs to start an opening HTML tag, then call this method, then
         * complete the opening and closing
         * @param oElement an instance of sap.ui.core.Element
         * @returns this render manager instance to allow chaining
        */
        writeInvisiblePlaceholderData(oElement: sap.ui.core.Element): sap.ui.core.RenderManager;

        /**
         * Writes and flushes the style collection
         * @returns this render manager instance to allow chaining
        */
        writeStyles(): sap.ui.core.RenderManager;
      }
      /**
       * Collects and stores the configuration of the current environment.The Configuration is initialized
       * once when the {@link sap.ui.core.Core} is created.There are different ways to set the environment
       * configuration (in ascending priority):<ol><li>System defined defaults<li>Server wide defaults, read
       * from /sap-ui-config.json<li>Properties of the global configuration object
       * window["sap-ui-config"]<li>A configuration string in the data-sap-ui-config attribute of the
       * bootstrap tag<li>Individual data-sap-ui-xyz attributes of the bootstrap tag<li>Using URL
       * parameters<li>Setters in this Configuration object (only for some parameters)</ol>That is,
       * attributes of the DOM reference override the system defaults, URL parametersoverride the DOM
       * attributes (where empty URL parameters set the parameter back to itssystem default). Calling setters
       * at runtime will override any previous settingscalculated during object creation.The naming
       * convention for parameters is:<ul><li>in the URL : sap-ui-<i>PARAMETER-NAME</i>="value"<li>in the DOM
       * : data-sap-ui-<i>PARAMETER-NAME</i>="value"</ul>where <i>PARAMETER-NAME</i> is the name of the
       * parameter in lower case.Values of boolean parameters are case insensitive where "true" and "x" are
       * interpreted as true.
       * @resource sap/ui/core/Configuration.js
      */
      export class Configuration extends sap.ui.base.Object {


        /**
         * Creates a new Configuration object.
        */
        constructor();



        /**
         * Applies multiple changes to the configuration at once.If the changed settings contain localization
         * related settings like <code>language</code>or <ode>calendarType</code>, then only a single
         * <code>localizationChanged</code> event willbe fired. As the framework has to inform all existing
         * components, elements, models etc.about localization changes, using <code>applySettings</code> can
         * significantly reduce theoverhead for multiple changes, esp. when they occur after the UI has been
         * created already.The <code>mSettings</code> can contain any property <code><i>xyz</i></code> for
         * which asetter method <code>set<i>XYZ</i></code> exists in the API of this class.Similarly, values
         * for the {@link sap.ui.core.Configuration.FormatSettings format settings}API can be provided in a
         * nested object with name <code>formatSettings</code>.
         * @since 1.38.6
         * @param mSettings Configuration options to apply
         * @returns Returns <code>this</code> to allow method chaining
        */
        applySettings(mSettings: any): sap.ui.core.Configuration;


        /**
         * Returns whether the accessibility mode is used or not
         * @returns whether the accessibility mode is used or not
        */
        getAccessibility(): boolean;

        /**
         * Returns whether the animations are globally used
         * @returns whether the animations are globally used
        */
        getAnimation(): boolean;

        /**
         * Base URLs to AppCacheBuster Etag-Index files
         * @returns array of base URLs
        */
        getAppCacheBuster(): string[];

        /**
         * Object defining the callback hooks for the AppCacheBuster like e.g.<code>handleURL</code>,
         * <code>onIndexLoad</code> or <code>onIndexLoaded</code>.
         * @returns object containing the callback functions for the AppCacheBuster
        */
        getAppCacheBusterHooks(): any;

        /**
         * The loading mode (sync|async|batch) of the AppCacheBuster (sync is default)
         * @returns sync | async
        */
        getAppCacheBusterMode(): string;

        /**
         * The name of the application to start or empty
         * @returns name of the application
        */
        getApplication(): string;

        /**
         * Returns whether the framework automatically adds automaticallythe ARIA role 'application' to the
         * html body or not.
         * @since 1.27.0
        */
        getAutoAriaBodyRole(): boolean;

        /**
         * Returns the used compatibility version for the given feature.
         * @param sFeature the key of desired feature
         * @returns the used compatibility version
        */
        getCompatibilityVersion(sFeature: string): any;

        /**
         * Return whether the controller code is deactivated. During design mode the
         * @since 1.26.4
         * @returns whether the activation of the controller code is suppressed or not
        */
        getControllerCodeDeactivated(): boolean;

        /**
         * Returns whether the page runs in debug mode
         * @returns whether the page runs in debug mode
        */
        getDebug(): boolean;

        /**
         * Return whether the design mode is active or not.
         * @since 1.13.2
         * @returns whether the design mode is active or not.
        */
        getDesignMode(): boolean;

        /**
         * Returns whether the Fiori2Adaptation is on
         * @returns false - no adaptation, true - full adaptation, comma-separated list - partial
         * adaptationPossible values: style, collapse, title, back, hierarchy
        */
        getFiori2Adaptation(): boolean | string;

        /**
         * Returns the format locale string with language and region code. Falls back tolanguage configuration,
         * in case it has not been explicitly defined.
         * @returns the format locale string with language and country code
        */
        getFormatLocale(): string;

        /**
         * Returns a configuration object that bundles the format settings of UI5.
         * @returns A FormatSettings object.
        */
        getFormatSettings(): sap.ui.core.Configuration.FormatSettings;

        /**
         * frameOptions mode (allow/deny/trusted).
         * @returns frameOptions mode
        */
        getFrameOptions(): string;

        /**
         * Returns whether the UI5 control inspector is displayedHas only an effect when the sap-ui-debug
         * module has been loaded
         * @returns whether the UI5 control inspector is displayed
        */
        getInspect(): boolean;

        /**
         * Returns a string that identifies the current language.The value returned by this methods in most
         * cases corresponds to the exact value that has beenconfigured by the user or application or that has
         * been determined from the user agent settings.It neither has been normalized nor validated against a
         * specification or standard, althoughUI5 expects a value compliant with {@link
         * http://www.ietf.org/rfc/bcp/bcp47.txt BCP47}.The exceptions mentioned above affect languages that
         * have been specified via the URL parameter<code>sap-language</code>. That parameter by definition
         * represents a SAP logon language code('ABAP language'). Most but not all of these language codes are
         * valid ISO639 two-letter languagesand as such are valid BCP47 language tags. For better BCP47
         * compliance, the frameworkmaps the following non-BCP47 SAP logon codes to a BCP47 substitute:<pre>  
         * "ZH"  -->  "zh-Hans"         // script 'Hans' added to distinguish it from zh-Hant   "ZF"  --> 
         * "zh-Hant"         // ZF ist not a valid ISO639 code, use the compliant language + script 'Hant'		 " 
         *   "1Q"  -->  "en-US-x-saptrc"  // special language code for supportability (tracing),               
         *                    represented as en-US with a priate extension   "2Q"  -->  "en-US-x-sappsd"  //
         * special language code for supportability (pseudo translation),                                  
         * represented as en-US with a priate extension</pre>
         * @returns The language string as configured
        */
        getLanguage(): string;

        /**
         * Returns a BCP47-compliant language tag for the current language.If the current {@link #getLanguage
         * language} can't be interpreted as aBCP47-compliant language, then the value <code>undefined</code>
         * is returned.
         * @returns The language tag for the current language, conforming to BCP47
        */
        getLanguageTag(): string;

        /**
         * Returns a Locale object for the current language.The Locale is derived from the {@link #getLanguage
         * language} property.
         * @returns The locale
        */
        getLocale(): sap.ui.core.Locale;

        /**
         * Flag whether a Component should load the manifest first
         * @since 1.33.0
         * @returns true if a Component should load the manifest first
        */
        getManifestFirst(): boolean;

        /**
         * Returns a metadata object for class sap.ui.core.Configuration.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Returns whether there should be an exception on any duplicate element IDs
         * @returns whether there should be an exception on any duplicate element IDs
        */
        getNoDuplicateIds(): boolean;

        /**
         * Returns whether the text origin information is collected
         * @returns whether the text info is collected
        */
        getOriginInfo(): boolean;

        /**
         * The name of the root component to start or empty
         * @returns name of the root component
        */
        getRootComponent(): string;

        /**
         * Returns whether the page uses the RTL text direction.If no mode has been explicitly set (neither
         * true nor false),the mode is derived from the current language setting.
         * @returns whether the page uses the RTL text direction
        */
        getRTL(): boolean;

        /**
         * Returns a SAP logon language for the current language.If the current {@link #getLanguage language}
         * can't be interpreted as aBCP47-compliant language, or if the BCP47 language can't be converted toa
         * SAP Logon language, then the value <code>undefined</code> is returned.
         * @returns The SAP logon language code for the current language
        */
        getSAPLogonLanguage(): string;

        /**
         * Return whether the activation of the controller code is suppressed
         * @since 1.13.2
         * @returns whether the activation of the controller code is suppressed or not
        */
        getSuppressDeactivationOfControllerCode(): boolean;

        /**
         * Returns the theme name
         * @returns the theme name
        */
        getTheme(): string;

        /**
         * Prefix to be used for automatically generated control IDs.Default is a double underscore "__".
         * @returns the prefix to be used
        */
        getUIDPrefix(): string;

        /**
         * Returns the version of the framework.Similar to <code>sap.ui.version</code>.
         * @returns the version
        */
        getVersion(): any;

        /**
         * URL of the whitelist service.
         * @returns whitelist service URL
        */
        getWhitelistService(): string;

        /**
         * Sets the new calendar type to be used from now on in locale dependent functionalities (for
         * example,formatting, translation texts, etc.).
         * @since 1.28.6
         * @param sCalendarType the new calendar type. Set it with null to clear the calendar type  and the
         * calendar type is calculated based on the format settings and current locale.
         * @returns <code>this</code> to allow method chaining
        */
        setCalendarType(sCalendarType: sap.ui.core.CalendarType | any): sap.ui.core.Configuration;

        /**
         * Sets a new formatLocale to be used from now on for retrieving localespecific formatters. Modifying
         * this setting does not have an impact onthe retrieval of translated texts!Can either be set to a
         * concrete value (a BCP-47 or Java locale compliantlanguage tag) or to <code>null</code>. When set to
         * <code>null</code> (defaultvalue) then locale specific formatters are retrieved for the current
         * language.After changing the formatLocale, the framework tries to update localizationspecific parts
         * of the UI. See the documentation of {@link #setLanguage} fordetails and restrictions.
         * @param sFormatLocale the new format locale as a BCP47 compliant language tag;  case doesn't matter
         * and underscores can be used instead of a dashes to separate  components (compatibility with Java
         * Locale Ids)
         * @returns <code>this</code> to allow method chaining
        */
        setFormatLocale(sFormatLocale: string | any): sap.ui.core.Configuration;

        /**
         * Sets a new language to be used from now on for language/region dependentfunctionality (e.g.
         * formatting, data types, translated texts, ...).When the language has changed, the Core will fire
         * its{@link sap.ui.core.Core#event:localizationChanged localizationChanged} event.The framework
         * <strong>does not</strong> guarantee that already created, languagedependent objects will be updated
         * by this call. It therefore remains best practicefor applications to switch the language early, e.g.
         * before any language dependentobjects are created. Applications that need to support more dynamic
         * changes ofthe language should listen to the <code>localizationChanged</code> event and adaptall
         * language dependent objects that they use (e.g. by rebuilding their UI).Currently, the framework
         * notifies the following objects about a change of thelocalization settings before it fires the
         * <code>localizationChanged</code> event:<ul><li>date and number data types that are used in property
         * bindings or composite    bindings in existing Elements, Controls, UIAreas or
         * Components</li><li>ResourceModels currently assigned to the Core, an UIArea, Component,    Element
         * or Control</li><li>Elements or Controls that implement the <code>onlocalizationChanged</code> hook  
         *  (note the lowercase 'l' in onlocalizationChanged)</ul>It furthermore derives the RTL mode from the
         * new language, if no explicit RTLmode has been set. If the RTL mode changes, the following additional
         * actions will be taken:<ul><li>the URLs of already loaded library theme files will be
         * changed</li><li>the <code>dir</code> attribute of the page will be changed to reflect the new
         * mode.</li><li>all UIAreas will be invalidated (which results in a rendering of the whole UI5
         * UI)</li></ul>This method does not handle SAP logon language codes.
         * @param sLanguage the new language as a BCP47 compliant language tag; case doesn't matter  and
         * underscores can be used instead of a dashes to separate components (compatibility with Java Locale
         * Ids)
         * @returns <code>this</code> to allow method chaining
        */
        setLanguage(sLanguage: string): sap.ui.core.Configuration;

        /**
         * Sets the character orientation mode to be used from now on.Can either be set to a concrete value
         * (true meaning right-to-left,false meaning left-to-right) or to <code>null</code> which means thatthe
         * character orientation mode should be derived from the currentlanguage (incl. region) setting.After
         * changing the character orientation mode, the framework triesto update localization specific parts of
         * the UI. See the documentation of{@link #setLanguage} for details and restrictions.
         * @param bRTL new character orientation mode or <code>null</code>
         * @returns <code>this</code> to allow method chaining
        */
        setRTL(bRTL: boolean | any): sap.ui.core.Configuration;
      }
      /**
       * Provides a trigger that triggers in a set interval and calls all       registered listeners. If the
       * interval is <= 0 the trigger is       switched off and won't trigger at all.
       * @resource sap/ui/core/IntervalTrigger.js
      */
      export class IntervalTrigger extends sap.ui.base.Object {


        /**
         * Creates an instance of EventBus.
         * @param iInterval is the interval the trigger should be used. If the           trigger is >0
         * triggering starts/runs and if the interval is           set to <=0 triggering stops.
        */
        constructor(iInterval: number);



        /**
         * Adds a listener to the list that should be triggered.
         * @param fnFunction is the called function that should be called when           the trigger want to
         * trigger the listener.
         * @param oListener that should be triggered.
        */
        addListener(fnFunction: any, oListener?: any): void;

        /**
         * Destructor method for objects.
        */
        destroy(bSuppressInvalidate: boolean): void;


        /**
        */
        getInterface(): sap.ui.base.Interface;

        /**
         * Returns a metadata object for class sap.ui.core.IntervalTrigger.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Removes corresponding listener from list.
         * @param fnFunction is the previously registered function
         * @param oListener that should be removed
        */
        removeListener(fnFunction: any, oListener?: any): void;

        /**
         * Sets the trigger interval. If the value is >0 triggering will start ifthere are any registered
         * listeners. If the interval is set to <=0triggering will stop.
         * @param iInterval sets the interval in milliseconds when a new           triggering should occur.
        */
        setInterval(iInterval: number): void;
      }
      /**
       * @resource sap/ui/core/ComponentMetadata.js
      */
      export class ComponentMetadata {


        /**
         * Creates a new metadata object for a Component subclass.
         * @param sClassName Fully qualified name of the class that is described by this metadata object
         * @param oStaticInfo Static info to construct the metadata from
        */
        constructor(sClassName: string, oStaticInfo: any);



        /**
         * Returns the name of the Component (which is the namespace only with the module name)
         * @returns Component name
        */
        getComponentName(): string;

        /**
         * Returns array of components specified in the metadata of the Component.If not specified or the array
         * is empty, the return value is null.<p><b>Important:</b></br>If a Component is loaded using the
         * manifest URL (or according the"manifest first" strategy), this function ignores the entries of
         * themanifest file! It returns only the entries which have been defined inthe Component metadata or in
         * the proper Component manifest.
         * @returns Required Components.
        */
        getComponents(): string[];

        /**
         * Returns a copy of the configuration property to disallow modifications.If no key is specified it
         * returns the complete configuration property
         * @since 1.15.1
         * @param sKey Key of the configuration property
         * @param bDoNotMerge If set to <code>true</code>, only the local configuration is returned
         * @returns the value of the configuration property
        */
        getConfig(sKey: string, bDoNotMerge?: boolean): any;

        /**
         * Returns the custom Component configuration entry with the specified key (this must be a JSON
         * object).If no key is specified, the return value is null.Example:<code> 
         * sap.ui.core.Component.extend("sample.Component", {      metadata: {          "my.custom.config" : { 
         *             "property1" : true,              "property2" : "Something else"          }      } 
         * });</code>The configuration above can be accessed via
         * <code>sample.Component.getMetadata().getCustomEntry("my.custom.config")</code>.
         * @param sKey Key of the custom configuration (must be prefixed with a namespace)
         * @param bMerged Indicates whether the custom configuration is merged with the parent custom
         * configuration of the Component.
         * @returns custom Component configuration with the specified key.
        */
        getCustomEntry(sKey: string, bMerged: boolean): any;

        /**
         * Returns the dependencies defined in the metadata of the Component. If not specified, the return
         * value is null.<p><b>Important:</b></br>If a Component is loaded using the manifest URL (or according
         * the"manifest first" strategy), this function ignores the entries of themanifest file! It returns
         * only the entries which have been defined inthe Component metadata or in the proper Component
         * manifest.
         * @returns Component dependencies.
        */
        getDependencies(): any;

        /**
         * Returns the array of the included files that the Component requires suchas CSS and JavaScript. If
         * not specified or the array is empty, the returnvalue is null.<p><b>Important:</b></br>If a Component
         * is loaded using the manifest URL (or according the"manifest first" strategy), this function ignores
         * the entries of themanifest file! It returns only the entries which have been defined inthe Component
         * metadata or in the proper Component manifest.
         * @returns Included files.
        */
        getIncludes(): string[];

        /**
         * Returns array of libraries specified in metadata of the Component, thatare automatically loaded when
         * an instance of the component is created.If not specified or the array is empty, the return value is
         * null.<p><b>Important:</b></br>If a Component is loaded using the manifest URL (or according
         * the"manifest first" strategy), this function ignores the entries of themanifest file! It returns
         * only the entries which have been defined inthe Component metadata or in the proper Component
         * manifest.
         * @returns Required libraries.
        */
        getLibs(): string[];

        /**
         * Returns the manifest defined in the metadata of the Component.If not specified, the return value is
         * null.
         * @since 1.27.1
         * @returns manifest.
        */
        getManifest(): any;

        /**
         * Returns the configuration of a manifest section or the value for aspecific path. If no section or
         * key is specified, the return value is null.Example:<code>  {    "sap.ui5": {      "dependencies": { 
         *       "libs": {          "sap.m": {}        },        "components": {          "my.component.a": {} 
         *       }      }  });</code>The configuration above can be accessed in the following
         * ways:<ul><li><b>By section/namespace</b>:
         * <code>oComponent.getMetadata().getManifestEntry("sap.ui5")</code></li><li><b>By path</b>:
         * <code>oComponent.getMetadata().getManifestEntry("/sap.ui5/dependencies/libs")</code></li></ul>By
         * section/namespace returns the configuration for the specified manifestsection and by path allows to
         * specify a concrete path to a dedicated entryinside the manifest. The path syntax always starts with
         * a slash (/).
         * @since 1.27.1
         * @param sKey Either the manifest section name (namespace) or a concrete path
         * @param bMerged Indicates whether the custom configuration is merged with the parent custom
         * configuration of the Component.
         * @returns Value of the manifest section or the key (could be any kind of value)
        */
        getManifestEntry(sKey: string, bMerged?: boolean): any | any;

        /**
         * Returns the manifest object.
         * @since 1.33.0
         * @returns manifest.
        */
        getManifestObject(): sap.ui.core.Manifest;

        /**
         * Returns the version of the metadata which could be 1 or 2. 1 is for legacymetadata whereas 2 is for
         * the manifest.
         * @since 1.27.1
         * @returns metadata version (1: legacy metadata, 2: manifest)
        */
        getMetadataVersion(): number;

        /**
         * Returns the raw manifest defined in the metadata of the Component.If not specified, the return value
         * is null.
         * @since 1.29.0
         * @returns manifest
        */
        getRawManifest(): any;

        /**
         * Returns the required version of SAPUI5 defined in the metadata of theComponent. If returned value is
         * null, then no special UI5 version isrequired.<p><b>Important:</b></br>If a Component is loaded using
         * the manifest URL (or according the"manifest first" strategy), this function ignores the entries of
         * themanifest file! It returns only the entries which have been defined inthe Component metadata or in
         * the proper Component manifest.
         * @returns Required version of UI5 or if not specified then null.
        */
        getUI5Version(): string;

        /**
         * Returns the version of the component. If not specified, the return valueis
         * null.<p><b>Important:</b></br>If a Component is loaded using the manifest URL (or according
         * the"manifest first" strategy), this function ignores the entries of themanifest file! It returns
         * only the entries which have been defined inthe Component metadata or in the proper Component
         * manifest.
         * @returns The version of the component.
        */
        getVersion(): string;

        /**
         * Returns whether the class of this metadata is a component base classor not.
         * @since 1.33.0
         * @returns true if it is sap.ui.core.Component or sap.ui.core.UIComponent
        */
        isBaseClass(): boolean;
      }
      /**
       * Helper Class for enhancement of a Control with propagation of enabled property.<b>This constructor
       * should be applied to the prototype of a
       * control</b>Example:<code>sap.ui.core.EnabledPropagator.call(<i>Some-Control</i>.prototype,
       * <i>Default-value,
       * @resource sap/ui/core/EnabledPropagator.js
      */
      export class EnabledPropagator {


        constructor(bDefault: boolean, bLegacy?: boolean);


      }
      /**
       * Allows to add multiple LayoutData to one control in case that a easy switch of layouts (e.g. in a
       * Form) is needed.
       * @resource sap/ui/core/VariantLayoutData.js
      */
      export class VariantLayoutData extends sap.ui.core.LayoutData {


        /**
         * Constructor for a new VariantLayoutData.Accepts an object literal <code>mSettings</code> that
         * defines initialproperty values, aggregated and associated objects as well as event handlers.See
         * {@link sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the
         * settings object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Adds some multipleLayoutData to the aggregation <code>multipleLayoutData</code>.
         * @param oMultipleLayoutData the multipleLayoutData to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addMultipleLayoutData(oMultipleLayoutData: sap.ui.core.LayoutData): sap.ui.core.VariantLayoutData;

        /**
         * Destroys all the multipleLayoutData in the aggregation <code>multipleLayoutData</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyMultipleLayoutData(): sap.ui.core.VariantLayoutData;


        /**
         * Returns a metadata object for class sap.ui.core.VariantLayoutData.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets content of aggregation <code>multipleLayoutData</code>.Allows multiple LayoutData.
        */
        getMultipleLayoutData(): sap.ui.core.LayoutData[];

        /**
         * Checks for the provided <code>sap.ui.core.LayoutData</code> in the aggregation
         * <code>multipleLayoutData</code>.and returns its index if found or -1 otherwise.
         * @param oMultipleLayoutData The multipleLayoutData whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfMultipleLayoutData(oMultipleLayoutData: sap.ui.core.LayoutData): number;

        /**
         * Inserts a multipleLayoutData into the aggregation <code>multipleLayoutData</code>.
         * @param oMultipleLayoutData the multipleLayoutData to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the multipleLayoutData should be inserted at; for      
         *       a negative value of <code>iIndex</code>, the multipleLayoutData is inserted at position 0; for
         * a value             greater than the current size of the aggregation, the multipleLayoutData is
         * inserted at             the last position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertMultipleLayoutData(oMultipleLayoutData: sap.ui.core.LayoutData, iIndex: number): sap.ui.core.VariantLayoutData;

        /**
         * Removes all the controls from the aggregation <code>multipleLayoutData</code>.Additionally, it
         * unregisters them from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllMultipleLayoutData(): sap.ui.core.LayoutData[];

        /**
         * Removes a multipleLayoutData from the aggregation <code>multipleLayoutData</code>.
         * @param vMultipleLayoutData The multipleLayoutData to remove or its index or id
         * @returns The removed multipleLayoutData or <code>null</code>
        */
        removeMultipleLayoutData(vMultipleLayoutData: number | string | sap.ui.core.LayoutData): sap.ui.core.LayoutData;
      }
      /**
       * The LocalBusyIndicator is a special version of theBusyIndicator. This one doesn't block the whole
       * screen - it justblocks the corresponding control and puts a local animation over thecontrol. To use
       * the functionality of this control the correspondingcontrol needs to be enabled via the
       * 'LocalBusyIndicatorSupport'accordingly to the ListBox control (see the init-function of theListBox).
       * @resource sap/ui/core/LocalBusyIndicator.js
      */
      export class LocalBusyIndicator extends sap.ui.core.Control {


        /**
         * Constructor for a new LocalBusyIndicator.Accepts an object literal <code>mSettings</code> that
         * defines initialproperty values, aggregated and associated objects as well as event handlers.See
         * {@link sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the
         * settings object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);




        /**
         * Gets current value of property <code>height</code>.This property is the height of the control that
         * has tobe covered. With this height the position of the animation can beproperly set.Default value is
         * <code>100px</code>.
         * @returns Value of property <code>height</code>
        */
        getHeight(): any;

        /**
         * Returns a metadata object for class sap.ui.core.LocalBusyIndicator.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>width</code>.This property is the width of the control that has
         * tobe covered. With this width the position of the animation can beproperly set.Default value is
         * <code>100px</code>.
         * @returns Value of property <code>width</code>
        */
        getWidth(): any;

        /**
         * Sets a new value for property <code>height</code>.This property is the height of the control that
         * has tobe covered. With this height the position of the animation can beproperly set.When called with
         * a value of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>100px</code>.
         * @param sHeight New value for property <code>height</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setHeight(sHeight: any): sap.ui.core.LocalBusyIndicator;

        /**
         * Sets a new value for property <code>width</code>.This property is the width of the control that has
         * tobe covered. With this width the position of the animation can beproperly set.When called with a
         * value of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>100px</code>.
         * @param sWidth New value for property <code>width</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setWidth(sWidth: any): sap.ui.core.LocalBusyIndicator;
      }
      /**
       * Static class for enabling declarative UI support.
       * @resource sap/ui/core/DeclarativeSupport.js
      */
      export class DeclarativeSupport {


        constructor();



        /**
         * Enhances the given DOM element by parsing the Control and Elements info and creatingthe SAPUI5
         * controls for them.
         * @param oElement the DOM element to compile
         * @param oView The view instance to use
         * @param isRecursive Whether the call of the function is recursive.
        */
        compile(oElement: sap.ui.core.Element, oView?: sap.ui.core.mvc.HTMLView, isRecursive?: boolean): void;
      }
      /**
       * Component Container
       * @resource sap/ui/core/ComponentContainer.js
      */
      export class ComponentContainer extends sap.ui.core.Control {


        /**
         * Constructor for a new ComponentContainer.Accepts an object literal <code>mSettings</code> that
         * defines initialproperty values, aggregated and associated objects as well as event handlers.See
         * {@link sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the
         * settings object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);




        /**
         * ID of the element which is the current target of the association <code>component</code>, or
         * <code>null</code>.
        */
        getComponent(): any;

        /**
         * Gets current value of property <code>handleValidation</code>.Enable/disable validation handling by
         * MessageManager for this component.The resulting Messages will be propagated to the controls.Default
         * value is <code>false</code>.
         * @returns Value of property <code>handleValidation</code>
        */
        getHandleValidation(): boolean;

        /**
         * Gets current value of property <code>height</code>.Container height in CSS size
         * @returns Value of property <code>height</code>
        */
        getHeight(): any;

        /**
         * Returns a metadata object for class sap.ui.core.ComponentContainer.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>name</code>.Component name, the package where the component is
         * contained. The property can only be applied initially.
         * @returns Value of property <code>name</code>
        */
        getName(): string;

        /**
         * Gets current value of property <code>propagateModel</code>.Defines whether binding information is
         * propagated to the component.Default value is <code>false</code>.
         * @returns Value of property <code>propagateModel</code>
        */
        getPropagateModel(): boolean;

        /**
         * Gets current value of property <code>settings</code>.The settings object passed to the component
         * when created. The property can only be applied initially.
         * @returns Value of property <code>settings</code>
        */
        getSettings(): any;

        /**
         * Gets current value of property <code>url</code>.The URL of the component. The property can only be
         * applied initially.
         * @returns Value of property <code>url</code>
        */
        getUrl(): any;

        /**
         * Gets current value of property <code>width</code>.Container width in CSS size
         * @returns Value of property <code>width</code>
        */
        getWidth(): any;

        /**
         * Sets the associated <code>component</code>.
         * @param oComponent ID of an element which becomes the new target of this component association;
         * alternatively, an element instance may be given
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setComponent(oComponent: any | sap.ui.core.UIComponent): sap.ui.core.ComponentContainer;

        /**
         * Sets a new value for property <code>handleValidation</code>.Enable/disable validation handling by
         * MessageManager for this component.The resulting Messages will be propagated to the controls.When
         * called with a value of <code>null</code> or <code>undefined</code>, the default value of the
         * property will be restored.Default value is <code>false</code>.
         * @param bHandleValidation New value for property <code>handleValidation</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setHandleValidation(bHandleValidation: boolean): sap.ui.core.ComponentContainer;

        /**
         * Sets a new value for property <code>height</code>.Container height in CSS sizeWhen called with a
         * value of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.
         * @param sHeight New value for property <code>height</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setHeight(sHeight: any): sap.ui.core.ComponentContainer;

        /**
         * Sets a new value for property <code>name</code>.Component name, the package where the component is
         * contained. The property can only be applied initially.When called with a value of <code>null</code>
         * or <code>undefined</code>, the default value of the property will be restored.
         * @param sName New value for property <code>name</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setName(sName: string): sap.ui.core.ComponentContainer;

        /**
         * Sets a new value for property <code>propagateModel</code>.Defines whether binding information is
         * propagated to the component.When called with a value of <code>null</code> or <code>undefined</code>,
         * the default value of the property will be restored.Default value is <code>false</code>.
         * @param bPropagateModel New value for property <code>propagateModel</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setPropagateModel(bPropagateModel: boolean): sap.ui.core.ComponentContainer;

        /**
         * Sets a new value for property <code>settings</code>.The settings object passed to the component when
         * created. The property can only be applied initially.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.
         * @param oSettings New value for property <code>settings</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setSettings(oSettings: any): sap.ui.core.ComponentContainer;

        /**
         * Sets a new value for property <code>url</code>.The URL of the component. The property can only be
         * applied initially.When called with a value of <code>null</code> or <code>undefined</code>, the
         * default value of the property will be restored.
         * @param sUrl New value for property <code>url</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setUrl(sUrl: any): sap.ui.core.ComponentContainer;

        /**
         * Sets a new value for property <code>width</code>.Container width in CSS sizeWhen called with a value
         * of <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
         * @param sWidth New value for property <code>width</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setWidth(sWidth: any): sap.ui.core.ComponentContainer;
      }
      /**
       * Marker interface for controls which are suitable for use as label.
       * @resource sap/ui/core/library.js
      */
      interface Label {


      }
      /**
       * 	Marker interface for toolbar controls.
       * @resource sap/ui/core/library.js
      */
      interface Toolbar {


      }
      /**
       * Interface for the controls which are suitable to shrink.This means the control should still look
       * fine when it gets smaller than its normal size,e.g. Text controls which can show ellipsis in case of
       * shrink.Note: This marker interface can be implemented by controls to give a hint to the
       * container.The control itself does not need to implement anything. A parent control that respects
       * this interfacewill apply the "flex-shrink" as a CSS property which determines how much the item will
       * shrink relativeto the rest of the items in the container when negative free space is distributed.
       * @resource sap/ui/core/library.js
      */
      interface IShrinkable {


      }
      /**
       * Marker interface for controls that are not rendered "embedded" into other controls but need to be
       * opened/closed.Such controls are handled differently during rendering.
       * @resource sap/ui/core/library.js
      */
      interface PopupInterface {


      }
      /**
       * Font design for texts
      */
      enum Design {
        "Monospace",
        "Standard"
      }
      /**
       * State of the Input Method Editor (IME) for the control.Depending on its value, it allows users to
       * enter and edit for example Chinese characters.
      */
      enum ImeMode {
        "Active",
        "Auto",
        "Disabled",
        "Inactive"
      }
      /**
       * Configuration options for text wrapping.
      */
      enum Wrapping {
        "Hard",
        "None",
        "Off",
        "Soft"
      }
      /**
       * Configuration options for the colors of a progress bar
      */
      enum BarColor {
        "CRITICAL",
        "NEGATIVE",
        "NEUTRAL",
        "POSITIVE"
      }
      /**
       * Priorities for general use.
      */
      enum Priority {
        "High",
        "Low",
        "Medium",
        "None"
      }
      /**
       * Defines the different possible states of an element that can be open or closed and does not
       * onlytoggle between these states, but also spends some time in between (e.g. because of an
       * animation).
      */
      enum OpenState {
        "CLOSED",
        "CLOSING",
        "OPEN",
        "OPENING"
      }
      /**
       * Semantic Colors of an icon.
      */
      enum IconColor {
        "Critical",
        "Default",
        "Negative",
        "Neutral",
        "Positive"
      }
      /**
       * Defines the possible values for horizontal and vertical scrolling behavior.
      */
      enum Scrolling {
        "Auto",
        "Hidden",
        "None",
        "Scroll"
      }
      /**
       * Configuration options for text alignments.
      */
      enum TextAlign {
        "Begin",
        "Center",
        "End",
        "Initial",
        "Left",
        "Right"
      }
      /**
       * Level of a title.
      */
      enum TitleLevel {
        "Auto",
        "H1",
        "H2",
        "H3",
        "H4",
        "H5",
        "H6"
      }
      /**
       * Marker for the correctness of the current value.
      */
      enum ValueState {
        "Error",
        "None",
        "Success",
        "Warning"
      }
      /**
       * Defines the different message types of a message
      */
      enum MessageType {
        "Error",
        "Information",
        "None",
        "Success",
        "Warning"
      }
      /**
       * Orientation of an UI element
      */
      enum Orientation {
        "Horizontal",
        "Vertical"
      }
      /**
       * The types of Calendar
      */
      enum CalendarType {
        "Gregorian",
        "Islamic",
        "Japanese"
      }
      /**
       * Configuration options for the direction of texts.
      */
      enum TextDirection {
        "Inherit",
        "LTR",
        "RTL"
      }
      /**
       * Configuration options for vertical alignments, for example of a layout cell content within the
       * borders.
      */
      enum VerticalAlign {
        "Bottom",
        "Inherit",
        "Middle",
        "Top"
      }
      /**
       * Defines the accessible roles for ARIA support. This enumeration is used with the AccessibleRole
       * control property.For more information, goto "Roles for Accessible Rich Internet Applications
       * (WAI-ARIA Roles)" at the www.w3.org homepage.
      */
      enum AccessibleRole {
        "Alert",
        "AlertDialog",
        "Application",
        "Banner",
        "Button",
        "Checkbox",
        "ColumnHeader",
        "Combobox",
        "ContentInfo",
        "Definition",
        "Description",
        "Dialog",
        "Directory",
        "Document",
        "Grid",
        "GridCell",
        "Group",
        "Heading",
        "Img",
        "Link",
        "List",
        "Listbox",
        "ListItem",
        "Log",
        "Main",
        "Marquee",
        "Menu",
        "Menubar",
        "MenuItem",
        "MenuItemCheckbox",
        "MenuItemRadio",
        "Navigation",
        "Note",
        "Option",
        "Presentation",
        "ProgressBar",
        "Radio",
        "RadioGroup",
        "Region",
        "Row",
        "RowHeader",
        "Search",
        "Secondary",
        "SeeAlso",
        "Separator",
        "Slider",
        "SpinButton",
        "Status",
        "Tab",
        "Tablist",
        "Tabpanel",
        "Textbox",
        "Timer",
        "Toolbar",
        "Tooltip",
        "Tree",
        "TreeGrid",
        "TreeItem"
      }
      /**
       * Actions are: Click on track, button, drag of thumb, or mouse wheel click
      */
      enum ScrollBarAction {
        "Drag",
        "MouseWheel",
        "Page",
        "Step"
      }
      /**
       * Configuration options for horizontal alignments of controls
      */
      enum HorizontalAlign {
        "Begin",
        "Center",
        "End",
        "Left",
        "Right"
      }
      /**
       * Defines the accessible landmark roles for ARIA support. This enumeration is used with the
       * AccessibleRole control property.For more information, goto "Roles for Accessible Rich Internet
       * Applications (WAI-ARIA Roles)" at the www.w3.org homepage.
      */
      enum AccessibleLandmarkRole {
        "Banner",
        "Complementary",
        "Main",
        "Navigation",
        "None",
        "Region",
        "Search"
      }
    }
    namespace model {

      /**
       * FormatException classThis exception is thrown, when an error occurs while trying to convert a value
       * of the model toa specific property value in the UI.
      */
      function FormatException(): void;

      /**
       * ParseException classThis exception is thrown, when a parse error occurs while converting astring
       * value to a specific property type in the model.
      */
      function ParseException(): void;

      /**
       * ValidateException classThis exception is thrown, when a validation error occurs while checking
       * thedefined constraints for a type.
      */
      function ValidateException(): void;
      namespace xml {
        /**
         * Model implementation for XML format
         * @resource sap/ui/model/xml/XMLModel.js
        */
        export class XMLModel extends sap.ui.model.ClientModel {


          /**
           * Constructor for a new XMLModel.
           * @param oData either the URL where to load the XML from or a XML
          */
          constructor(oData: any);




          /**
           * Returns a metadata object for class sap.ui.model.xml.XMLModel.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Returns the object for the given <code>path</code>
           * @param sPath the path to the object
           * @param oContext the context which will be used to retrieve the object
           * @returns the object
          */
          getObject(sPath: string, oContext?: any): any;

          /**
           * Returns the value for the property with the given <code>sPropertyName</code>
           * @param sPath the path to the property
           * @param oContext the context which will be used to retrieve the property
          */
          getProperty(sPath: string, oContext?: any): any;

          /**
           * Serializes the current XML data of the model into a string.
          */
          getXML(): void;

          /**
           * Load XML-encoded data from the server using a GET HTTP request and store the resulting XML data in
           * the model.Note: Due to browser security restrictions, most "Ajax" requests are subject to the same
           * origin policy,the request can not successfully retrieve data from a different domain, subdomain, or
           * protocol.
           * @param sURL A string containing the URL to which the request is sent.
           * @param oParameters A map or string that is sent to the server with the request.
           * @param bAsync if the request should be asynchron or not. Default is true.
           * @param sType of request. Default is 'GET'
           * @param bCache force no caching if false. Default is false
           * @param mHeaders An object of additional header key/value pairs to send along with the request
          */
          loadData(sURL: string, oParameters: any | string, bAsync: boolean, sType: string, bCache: string, mHeaders: any): void;

          /**
           * Sets the provided XML encoded data object to the model
           * @param oData the data to set to the model
          */
          setData(oData: any): void;

          /**
           * Sets an XML namespace to use in the binding path
           * @param sNameSpace the namespace URI
           * @param sPrefix the prefix for the namespace (optional)
          */
          setNameSpace(sNameSpace: string, sPrefix?: string): void;

          /**
           * Sets a new value for the given property <code>sPropertyName</code> in the model.If the model value
           * changed all interested parties are informed.
           * @param sPath path of the property to set
           * @param oValue value to set the property to
           * @param oContext the context which will be used to set the property
           * @param bAsyncUpdate whether to update other bindings dependent on this property asynchronously
           * @returns true if the value was set correctly and false if errors occurred like the entry was not
           * found.
          */
          setProperty(sPath: string, oValue: any, oContext?: any, bAsyncUpdate?: boolean): boolean;

          /**
           * Sets the specified XML formatted string text to the model
           * @param sXMLText the XML data as string
          */
          setXML(sXMLText: string): void;
        }
      }
      namespace json {
        /**
         * Model implementation for JSON formatThe observation feature is experimental! When observation is
         * activated, the application can directly change theJS objects without the need to call setData,
         * setProperty or refresh. Observation does only work for existingproperties in the JSON, it can not
         * detect new properties or new array entries.
         * @resource sap/ui/model/json/JSONModel.js
        */
        export class JSONModel extends sap.ui.model.ClientModel {


          /**
           * Constructor for a new JSONModel.
           * @param oData either the URL where to load the JSON from or a JS object
           * @param bObserve whether to observe the JSON data for property changes (experimental)
          */
          constructor(oData: any, bObserve?: boolean);




          /**
           * Serializes the current JSON data of the model into a string.Note: May not work in Internet Explorer
           * 8 because of lacking JSON support (works only if IE 8 mode is enabled)
           * @returns sJSON the JSON data serialized as string
          */
          getJSON(): string;

          /**
           * Returns a metadata object for class sap.ui.model.json.JSONModel.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Returns the value for the property with the given <code>sPropertyName</code>
           * @param sPath the path to the property
           * @param oContext the context which will be used to retrieve the property
          */
          getProperty(sPath: string, oContext?: any): any;

          /**
           * Load JSON-encoded data from the server using a GET HTTP request and store the resulting JSON data in
           * the model.Note: Due to browser security restrictions, most "Ajax" requests are subject to the same
           * origin policy,the request can not successfully retrieve data from a different domain, subdomain, or
           * protocol.
           * @param sURL A string containing the URL to which the request is sent.
           * @param oParameters A map or string that is sent to the server with the request.Data that is sent to
           * the server is appended to the URL as a query string.If the value of the data parameter is an object
           * (map), it is converted to a string andurl-encoded before it is appended to the URL.
           * @param bAsync By default, all requests are sent asynchronous(i.e. this is set to true by default).
           * If you need synchronous requests, set this option to false.Cross-domain requests do not support
           * synchronous operation. Note that synchronous requests maytemporarily lock the browser, disabling any
           * actions while the request is active.
           * @param sType The type of request to make ("POST" or "GET"), default is "GET".Note: Other HTTP
           * request methods, such as PUT and DELETE, can also be used here, butthey are not supported by all
           * browsers.
           * @param bMerge whether the data should be merged instead of replaced
           * @param bCache force no caching if false. Default is false
           * @param mHeaders An object of additional header key/value pairs to send along with the request
          */
          loadData(sURL: string, oParameters?: any | string, bAsync?: boolean, sType?: string, bMerge?: boolean, bCache?: string, mHeaders?: any): void;

          /**
           * Sets the JSON encoded data to the model.
           * @param oData the data to set on the model
           * @param bMerge whether to merge the data instead of replacing it
          */
          setData(oData: any, bMerge?: boolean): void;

          /**
           * Sets the JSON encoded string data to the model.
           * @param sJSONText the string data to set on the model
           * @param bMerge whether to merge the data instead of replacing it
          */
          setJSON(sJSONText: string, bMerge?: boolean): void;

          /**
           * Sets a new value for the given property <code>sPropertyName</code> in the model.If the model value
           * changed all interested parties are informed.
           * @param sPath path of the property to set
           * @param oValue value to set the property to
           * @param oContext the context which will be used to set the property
           * @param bAsyncUpdate whether to update other bindings dependent on this property asynchronously
           * @returns true if the value was set correctly and false if errors occurred like the entry was not
           * found.
          */
          setProperty(sPath: string, oValue: any, oContext?: any, bAsyncUpdate?: boolean): boolean;
        }
      }
      namespace type {
        /**
         * This class represents date simple types.
         * @resource sap/ui/model/type/Date.js
        */
        export class Date extends sap.ui.model.SimpleType {


          /**
           * Constructor for a Date type.
           * @param oFormatOptions options used to create a DateFormat for formatting / parsing. Supports the
           * same options as {@link sap.ui.core.format.DateFormat.getDateInstance DateFormat.getDateInstance}
           * @param oConstraints value constraints.
          */
          constructor(oFormatOptions: any, oConstraints?: any);




          /**
           * Returns a metadata object for class sap.ui.model.type.Date.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
          */
          getOutputPattern(): void;
        }
        /**
         * This class represents time simple types.
         * @resource sap/ui/model/type/Time.js
        */
        export class Time extends sap.ui.model.type.Date {


          /**
           * Constructor for a Time type.
           * @param oFormatOptions options used to create a DateFormat for formatting / parsing to/from external
           * values and          optionally for a second DateFormat to convert between the data source format
           * (Model) and the internally used JavaScript Date.format.          For both DateFormat objects, the
           * same options are supported as for {@link sap.ui.core.format.DateFormat.getTimeInstance
           * DateFormat.getTimeInstance}.          Note that this differs from the base type.
           * @param oConstraints value constraints. Supports the same kind of constraints as its base type Date,
           * but note the different format options (Date vs. Time)
          */
          constructor(oFormatOptions: any, oConstraints?: any);




          /**
           * Returns a metadata object for class sap.ui.model.type.Time.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;
        }
        /**
         * This class represents float simple types.
         * @resource sap/ui/model/type/Float.js
        */
        export class Float extends sap.ui.model.SimpleType {


          /**
           * Constructor for a Float type.
           * @param oFormatOptions formatting options. Supports the same options as {@link
           * sap.ui.core.format.NumberFormat.getFloatInstance NumberFormat.getFloatInstance}
           * @param oConstraints value constraints.
          */
          constructor(oFormatOptions: any, oConstraints?: any);




          /**
           * Returns a metadata object for class sap.ui.model.type.Float.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;
        }
        /**
         * This class represents string simple types.
         * @resource sap/ui/model/type/String.js
        */
        export class String extends sap.ui.model.SimpleType {


          /**
           * Constructor for a String type.
           * @param oFormatOptions formatting options. String doesn't support any formatting options
           * @param oConstraints value constraints. All given constraints must be fulfilled by a value to be
           * valid
          */
          constructor(oFormatOptions: any, oConstraints?: any);




          /**
           * Returns a metadata object for class sap.ui.model.type.String.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;
        }
        /**
         * This class represents integer simple types.
         * @resource sap/ui/model/type/Integer.js
        */
        export class Integer extends sap.ui.model.SimpleType {


          /**
           * Constructor for a Integer type.
           * @param oFormatOptions formatting options. Supports the same options as {@link
           * sap.ui.core.format.NumberFormat.getIntegerInstance NumberFormat.getIntegerInstance}
           * @param oConstraints value constraints.
          */
          constructor(oFormatOptions: any, oConstraints?: any);




          /**
           * Returns a metadata object for class sap.ui.model.type.Integer.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;
        }
        /**
         * This class represents boolean simple types.
         * @resource sap/ui/model/type/Boolean.js
        */
        export class Boolean extends sap.ui.model.SimpleType {


          /**
           * Constructor for a Boolean type.
           * @param oFormatOptions formatting options. Boolean doesn't support any specific format options
           * @param oConstraints value constraints. Boolean doesn't support additional constraints
          */
          constructor(oFormatOptions: any, oConstraints?: any);




          /**
           * Returns a metadata object for class sap.ui.model.type.Boolean.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;
        }
        /**
         * This class represents the currency composite type.
         * @resource sap/ui/model/type/Currency.js
        */
        export class Currency extends sap.ui.model.CompositeType {


          /**
           * Constructor for a Currency type.
           * @param oFormatOptions formatting options. Supports the same options as {@link
           * sap.ui.core.format.NumberFormat.getCurrencyInstance NumberFormat.getCurrencyInstance}
           * @param oConstraints value constraints.
          */
          constructor(oFormatOptions: any, oConstraints?: any);




          /**
           * Format the given array containing amount and currency code to an output value of type string.Other
           * internal types than 'string' are not supported by the Currency type.If an source format is has been
           * defined for this type, the formatValue does also accepta string value as input, which will be parsed
           * into an array using the source format.If aValues is not defined or null, null will be returned.
           * @param vValue the array of values or string value to be formatted
           * @param sInternalType the target type
           * @returns the formatted output value
          */
          formatValue(vValue: any[] | string, sInternalType: string): any;

          /**
           * Returns a metadata object for class sap.ui.model.type.Currency.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Parse a string value to an array containing amount and currency. Parsing of otherinternal types than
           * 'string' is not supported by the Currency type.In case a source format has been defined, after
           * parsing the currency is formattedusing the source format and a string value is returned instead.
           * @param vValue the value to be parsed
           * @param sInternalType the source type
           * @param aCurrentValues the current values of all binding parts
           * @returns the parse result array
          */
          parseValue(vValue: any, sInternalType: string, aCurrentValues: any[]): any[] | string;
        }
        /**
         * This class represents datetime simple types.
         * @resource sap/ui/model/type/DateTime.js
        */
        export class DateTime extends sap.ui.model.type.Date {


          /**
           * Constructor for a DateTime type.
           * @param oFormatOptions options used to create a DateFormat for formatting / parsing to/from external
           * values and          optionally for a second DateFormat to convert between the data source format
           * (Model) and the internally used JavaScript Date.format.          For both DateFormat objects, the
           * same options are supported as for {@link sap.ui.core.format.DateFormat.getDateTimeInstance
           * DateFormat.getDateTimeInstance}.          Note that this differs from the base type.
           * @param oConstraints value constraints. Supports the same kind of constraints as its base type Date,
           * but note the different format options (Date vs. DateTime)
          */
          constructor(oFormatOptions: any, oConstraints?: any);




          /**
           * Returns a metadata object for class sap.ui.model.type.DateTime.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;
        }
        /**
         * This class represents file size simple types.
         * @resource sap/ui/model/type/FileSize.js
        */
        export class FileSize extends sap.ui.model.SimpleType {


          /**
           * Constructor for a FileSize type.
           * @param oFormatOptions formatting options. Supports the same options as {@link
           * sap.ui.core.format.FileSizeFormat.getInstance FileSizeFormat.getInstance}
           * @param oConstraints value constraints.
          */
          constructor(oFormatOptions: any, oConstraints?: any);




          /**
           * Returns a metadata object for class sap.ui.model.type.FileSize.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;
        }
      }
      namespace odata {

        /**
         * Adapter for TreeBindings to add the ListBinding functionality and use thetree structure in list
         * based controls.
        */
        function ODataTreeBindingAdapter(): void;

        /**
         * Adapter for TreeBindings to add the ListBinding functionality and use thetree structure in list
         * based controls.
        */
        function ODataTreeBindingFlat(): void;
        namespace v4 {
          /**
           * Implementation of an OData V4 model's context.  The context is a pointer to model data as returned
           * by a query from a  {@link sap.ui.model.odata.v4.ODataContextBinding context binding} or a  {@link
           * sap.ui.model.odata.v4.ODataListBinding list binding}. Contexts are always and only  created by such
           * bindings. A context for a context binding points to the complete query  result. A context for a list
           * binding points to one specific entry in the binding's  collection. A property binding does not have
           * a context, you can access its value via  {@link sap.ui.model.odata.v4.ODataPropertyBinding#getValue
           * getValue}.  Applications can access model data only via a context, either synchronously with the
           * risk  that the values are not available yet ({@link #getProperty} and {@link #getObject}) or 
           * asynchronously ({@link #requestProperty} and {@link #requestObject}).
           * @resource sap/ui/model/odata/v4/Context.js
          */
          export class Context extends sap.ui.model.Context {

            /**
             * Returns the "canonical path" of the entity for this context.According to "4.3.1 Canonical URL" of
             * the specification "OData Version 4.0 Part 2: URLConventions", this is the "name of the entity set
             * associated with the entity followed by thekey predicate identifying the entity within the
             * collection".Use the canonical path in {@link sap.ui.core.Element#bindElement} to create an
             * elementbinding.
             * @since 1.39.0
            */
            public getCanonicalPath: any;

            /**
             * Returns a promise for the "canonical path" of the entity for this context.According to "4.3.1
             * Canonical URL" of the specification "OData Version 4.0 Part 2: URLConventions", this is the "name of
             * the entity set associated with the entity followed by thekey predicate identifying the entity within
             * the collection".Use the canonical path in {@link sap.ui.core.Element#bindElement} to create an
             * elementbinding.
             * @since 1.39.0
            */
            public requestCanonicalPath: any;


            /**
             * Do <strong>NOT</strong> call this private constructor for a new <code>Context</code>. In theOData V4
             * model you cannot create contexts at will: retrieve them from a binding or a viewelement instead.
             * @param oModel The model
             * @param oBinding A binding that belongs to the model
             * @param sPath An absolute path without trailing slash
             * @param iIndex Index of item (within the collection addressed by <code>sPath</code>) represented  by
             * this context; used by list bindings, not context bindings
            */
            constructor(oModel: sap.ui.model.odata.v4.ODataModel, oBinding: sap.ui.model.odata.v4.ODataContextBinding | sap.ui.model.odata.v4.ODataListBinding, sPath: string, iIndex?: number);




            /**
             * Returns the binding this context belongs to.
             * @since 1.39.0
             * @returns The context's binding
            */
            getBinding(): sap.ui.model.odata.v4.ODataContextBinding | sap.ui.model.odata.v4.ODataListBinding;

            /**
             * Returns the context's index within the binding's collection.
             * @since 1.39.0
             * @returns The context's index within the binding's collection or <code>undefined</code> if the 
             * context does not belong to a list binding.
            */
            getIndex(): number;

            /**
             * Returns a metadata object for class sap.ui.model.odata.v4.Context.
             * @returns Metadata object describing this class
            */
            getMetadata(): sap.ui.base.Metadata;

            /**
             * Returns the value for the given path relative to this context. The function allows access tothe
             * complete data the context points to (when <code>sPath</code> is "") or any part thereof.The data is
             * a JSON structure as described in<a
             * href="http://docs.oasis-open.org/odata/odata-json-format/v4.0/odata-json-format-v4.0.html">"OData
             * JSON Format Version 4.0"</a>.Note that the function clones the result. Modify values via{@link
             * sap.ui.model.odata.v4.ODataPropertyBinding#setValue}.Returns <code>undefined</code> if the data is
             * not (yet) available. Use{@link #requestObject} for asynchronous access.
             * @since 1.39.0
             * @param sPath A relative path within the JSON structure
             * @returns The requested value
            */
            getObject(sPath: string): any;

            /**
             * Returns the property value for the given path relative to this context. The path is expectedto point
             * to a structural property with primitive type. Returns <code>undefined</code>if the data is not (yet)
             * available. Use {@link #requestProperty} for asynchronous access.
             * @since 1.39.0
             * @param sPath A relative path within the JSON structure
             * @param bExternalFormat If <code>true</code>, the value is returned in external format using a UI5
             * type for the  given property path that formats corresponding to the property's EDM type and
             * constraints.  If the type is not yet available, <code>undefined</code> is returned.
            */
            getProperty(sPath: string, bExternalFormat?: boolean): any;

            /**
             * Returns a promise on the value for the given path relative to this context. The functionallows
             * access to the complete data the context points to (when <code>sPath</code> is "") orany part
             * thereof. The data is a JSON structure as described in<a
             * href="http://docs.oasis-open.org/odata/odata-json-format/v4.0/odata-json-format-v4.0.html">"OData
             * JSON Format Version 4.0"</a>.Note that the function clones the result. Modify values via{@link
             * sap.ui.model.odata.v4.ODataPropertyBinding#setValue}.
             * @since 1.39.0
             * @param sPath A relative path within the JSON structure
             * @returns A promise on the requested value
            */
            requestObject(sPath: string): JQueryPromise<any>;

            /**
             * Returns a promise on the property value for the given path relative to this context. The pathis
             * expected to point to a structural property with primitive type.
             * @since 1.39.0
             * @param sPath A relative path within the JSON structure
             * @param bExternalFormat If <code>true</code>, the value is returned in external format using a UI5
             * type for the  given property path that formats corresponding to the property's EDM type and
             * constraints.
             * @returns A promise on the requested value; it is rejected if the value is not primitive
            */
            requestProperty(sPath: string, bExternalFormat?: boolean): JQueryPromise<any>;

            /**
             * Returns a string representation of this object including the binding path.
             * @since 1.39.0
             * @returns A string description of this binding
            */
            toString(): string;
          }
          /**
           * Model implementation for OData V4.  Every resource path (relative to the service root URL, no query
           * options) according to  "4 Resource Path" in specification "OData Version 4.0 Part 2: URL
           * Conventions" is  a valid data binding path within this model if a leading slash is added; for
           * example  "/" + "EMPLOYEES('A%2FB%26C')" to access an entity instance with key "A/B&C". Note that 
           * appropriate URI encoding is necessary. "4.5.1 Addressing Actions" needs an operation  binding, see
           * {@link sap.ui.model.odata.v4.ODataContextBinding}.  Note that the OData V4 model has its own {@link
           * sap.ui.model.odata.v4.Context} class.  The model does not support any public events; attaching an
           * event handler leads to an error.
           * @resource sap/ui/model/odata/v4/ODataModel.js
          */
          export class ODataModel extends sap.ui.model.Model {


            /**
             * Constructor for a new ODataModel.
             * @param mParameters The parameters
            */
            constructor(mParameters: any);



            /**
             * Creates a new context binding for the given path, context and parameters.This binding is inactive
             * and will not know the bound context initially.You have to call {@link
             * sap.ui.model.Binding#initialize initialize()} to get it updatedasynchronously and register a change
             * listener at the binding to be informed when the boundcontext is available.
             * @since 1.37.0
             * @param sPath The binding path in the model; must not end with a slash
             * @param oContext The context which is required as base for a relative path
             * @param mParameters Map of binding parameters which can be OData query options as specified in 
             * "OData Version 4.0 Part 2: URL Conventions" or the binding-specific parameters "$$groupId"  and
             * "$$updateGroupId".  Note: If parameters are provided for a relative binding path, the binding
             * accesses data  with its own service requests instead of using its parent binding.  The following
             * OData query options are allowed:  <ul>  <li> All "5.2 Custom Query Options" except for those with a
             * name starting with "sap-"  <li> The $expand, $filter, $orderby and $select "5.1 System Query
             * Options"; OData V4 only  allows $filter and $orderby inside resource paths that identify a
             * collection. In our case  here, this means you can only use them inside $expand.  </ul>  All other
             * query options lead to an error.  Query options specified for the binding overwrite model query
             * options.
             * @returns The context binding
            */
            bindContext(sPath: string, oContext?: sap.ui.model.odata.v4.Context, mParameters?: any): sap.ui.model.odata.v4.ODataContextBinding;

            /**
             * Creates a new list binding for the given path and optional context which mustresolve to an absolute
             * OData path for an entity set.
             * @since 1.37.0
             * @param sPath The binding path in the model; must not be empty or end with a slash
             * @param oContext The context which is required as base for a relative path
             * @param vSorters The dynamic sorters to be used initially. Call  {@link
             * sap.ui.model.odata.v4.ODataListBinding#sort} to replace them. Static sorters, as  defined in the
             * '$orderby' binding parameter, are always executed after the dynamic sorters.  Supported since
             * 1.39.0.
             * @param vFilters The dynamic application filters to be used initially. Call  {@link
             * sap.ui.model.odata.v4.ODataListBinding#filter} to replace them. Static filters,  as defined in the
             * '$filter' binding parameter, are always combined with the dynamic  filters using a logical
             * <code>AND</code>.  Supported since 1.39.0.
             * @param mParameters Map of binding parameters which can be OData query options as specified in 
             * "OData Version 4.0 Part 2: URL Conventions" or the binding-specific parameters "$$groupId"  and
             * "$$updateGroupId".  Note: If parameters are provided for a relative binding path, the binding
             * accesses data  with its own service requests instead of using its parent binding.  The following
             * OData query options are allowed:  <ul>  <li> All "5.2 Custom Query Options" except for those with a
             * name starting with "sap-"  <li> The $expand, $filter, $orderby and $select "5.1 System Query
             * Options"  </ul>  All other query options lead to an error.  Query options specified for the binding
             * overwrite model query options.
             * @returns The list binding
            */
            bindList(sPath: string, oContext?: sap.ui.model.odata.v4.Context, vSorters?: sap.ui.model.Sorter | sap.ui.model.Sorter[], vFilters?: sap.ui.model.Filter | sap.ui.model.Filter[], mParameters?: any): sap.ui.model.odata.v4.ODataListBinding;

            /**
             * Creates a new property binding for the given path. This binding is inactive and will notknow the
             * property value initially. You have to call {@link sap.ui.model.Binding#initializeinitialize()} to
             * get it updated asynchronously and register a change listener at the bindingto be informed when the
             * value is available.
             * @since 1.37.0
             * @param sPath The binding path in the model; must not be empty or end with a slash
             * @param oContext The context which is required as base for a relative path
             * @param mParameters Map of binding parameters which can be OData query options as specified in 
             * "OData Version 4.0 Part 2: URL Conventions" or the binding-specific parameters "$$groupId"  and
             * "$$updateGroupId".  Note: Binding parameters may only be provided for absolute binding paths as only
             * those  lead to a data service request.  All "5.2 Custom Query Options" are allowed except for those
             * with a name starting with  "sap-". All other query options lead to an error.  Query options
             * specified for the binding overwrite model query options.
             * @returns The property binding
            */
            bindProperty(sPath: string, oContext?: sap.ui.model.odata.v4.Context, mParameters?: any): sap.ui.model.odata.v4.ODataPropertyBinding;

            /**
             * Method not supported
             * @since 1.37.0
            */
            bindTree(sPath: string, oContext?: any, aFilters?: any[], mParameters?: any, aSorters?: any[]): sap.ui.model.TreeBinding;

            /**
             * Cannot create contexts at this model at will; retrieve them from a binding instead.
             * @since 1.37.0
            */
            createBindingContext(sPath: string, oContext?: any, mParameters?: any, fnCallBack?: any, bReload?: boolean): sap.ui.model.Context;

            /**
             * Destroys this model and its meta model.
             * @since 1.38.0
            */
            destroy(bSuppressInvalidate: boolean): void;

            /**
             * Method not supported
             * @since 1.37.0
            */
            destroyBindingContext(): void;

            /**
             * Returns the meta model for this ODataModel.
             * @since 1.37.0
             * @returns The meta model for this ODataModel
            */
            getMetaModel(): sap.ui.model.odata.v4.ODataMetaModel;

            /**
             * Method not supported
             * @since 1.37.0
            */
            getObject(): void;

            /**
             * Method not supported
             * @since 1.37.0
            */
            getOriginalProperty(): void;

            /**
             * Method not supported
             * @since 1.37.0
            */
            getProperty(): void;

            /**
             * Returns <code>true</code> if there are pending changes that would be reset by{@link #refresh}.
             * @since 1.39.0
             * @returns <code>true</code> if there are pending changes
            */
            hasPendingChanges(): boolean;

            /**
             * Method not supported
             * @since 1.37.0
            */
            isList(): void;

            /**
             * Refreshes the model by calling refresh on all bindings which have a change event
             * handlerattached.Note: When calling refresh multiple times, the result of the request triggered by
             * the lastcall determines the model's data; it is <b>independent</b>of the order of calls to {@link
             * #submitBatch} with the given group ID.
             * @since 1.37.0
             * @param sGroupId The group ID to be used for refresh; valid values are <code>undefined</code>, 
             * <code>'$auto'</code>, <code>'$direct'</code> or application group IDs as specified in  {@link
             * #submitBatch}
            */
            refresh(sGroupIdOrForceUpdate: string | boolean): void;

            /**
             * Returns a promise for the "canonical path" of the entity for the given context.According to "4.3.1
             * Canonical URL" of the specification "OData Version 4.0 Part 2: URLConventions", this is the "name of
             * the entity set associated with the entity followed by thekey predicate identifying the entity within
             * the collection".Use the canonical path in {@link sap.ui.core.Element#bindElement} to create an
             * elementbinding.
             * @since 1.37.0
             * @param oEntityContext A context in this model which must point to a non-contained OData entity
             * @returns A promise which is resolved with the canonical path (e.g. "/EMPLOYEES(ID='1')") in case of 
             * success, or rejected with an instance of <code>Error</code> in case of failure, e.g. when  the given
             * context does not point to an entity
            */
            requestCanonicalPath(oEntityContext: sap.ui.model.odata.v4.Context): JQueryPromise<any>;

            /**
             * Resets all property changes associated with the given application group ID which have notyet been
             * submitted via {@link #submitBatch}.
             * @since 1.39.0
             * @param sGroupId The application group ID, which is a non-empty string consisting of alphanumeric 
             * characters from the basic Latin alphabet, including the underscore. If it is 
             * <code>undefined</code>, the model's <code>updateGroupId</code> is used. Note that the  default
             * <code>updateGroupId</code> is "$auto", which is invalid here.
            */
            resetChanges(sGroupId: string): void;

            /**
             * Method not supported
             * @since 1.37.0
            */
            setLegacySyntax(): void;

            /**
             * Submits the requests associated with the given application group ID in one batch request.
             * @since 1.37.0
             * @param sGroupId The application group ID, which is a non-empty string consisting of alphanumeric 
             * characters from the basic Latin alphabet, including the underscore.
             * @returns A promise on the outcome of the HTTP request resolving with <code>undefined</code>; it is 
             * rejected with an error if the batch request itself fails
            */
            submitBatch(sGroupId: string): JQueryPromise<any>;

            /**
             * Returns a string representation of this object including the service URL.
             * @since 1.37.0
             * @returns A string description of this model
            */
            toString(): string;
          }
          /**
           * Implementation of an OData meta data model which offers access to OData V4 meta data.  The meta
           * model does not support any public events; attaching an event handler leads to an  error.  This model
           * is read-only.
           * @resource sap/ui/model/odata/v4/ODataMetaModel.js
          */
          export class ODataMetaModel extends sap.ui.model.MetaModel {


            /**
             * Do <strong>NOT</strong> call this private constructor for a new <code>ODataMetaModel</code>,but
             * rather use {@link sap.ui.model.odata.v4.ODataModel#getMetaModel getMetaModel} instead.
             * @param oRequestor The meta data requestor
             * @param sUrl The URL to the $metadata document of the service
            */
            constructor(oRequestor: any, sUrl: string);



            /**
             * Creates a list binding for this meta data model which iterates content from the given path(relative
             * to the given context), sorted and filtered as indicated.By default, OData names are iterated and a
             * trailing slash is implicitly added to the path(see {@link #requestObject requestObject} for the
             * effects this has); technical propertiesand inline annotations are filtered out.A path which ends
             * with an "@" segment can be used to iterate all inline or externaltargeting annotations; no trailing
             * slash is added implicitly; technical properties and ODatanames are filtered out.
             * @since 1.37.0
             * @param sPath A relative or absolute path within the meta data model, for example "/EMPLOYEES"
             * @param oContext The context to be used as a starting point in case of a relative path
             * @param aSorters Initial sort order, see {@link sap.ui.model.ListBinding#sort sort}
             * @param aFilters Initial application filter(s), see {@link sap.ui.model.ListBinding#filter filter}
             * @returns A list binding for this meta data model
            */
            bindList(sPath: string, oContext?: sap.ui.model.Context, aSorters?: sap.ui.model.Sorter | sap.ui.model.Sorter[], aFilters?: sap.ui.model.Filter | sap.ui.model.Filter[]): sap.ui.model.ListBinding;

            /**
             * Method not supported
             * @since 1.37.0
            */
            bindTree(sPath: string, oContext?: any, aFilters?: any[], mParameters?: any, aSorters?: any[]): sap.ui.model.TreeBinding;


            /**
             * Returns the OData meta data model context corresponding to the given OData data model path.
             * @since 1.37.0
             * @param sPath An absolute data path within the OData data model, for example 
             * "/EMPLOYEES/0/ENTRYDATE"
             * @returns The corresponding meta data context within the OData meta data model, for example with 
             * meta data path "/EMPLOYEES/ENTRYDATE"
            */
            getMetaContext(sPath: string): sap.ui.model.Context;

            /**
             * Returns a metadata object for class sap.ui.model.odata.v4.ODataMetaModel.
             * @returns Metadata object describing this class
            */
            getMetadata(): sap.ui.base.Metadata;

            /**
             * Returns the meta data object for the given path relative to the given context.
             * Returns<code>undefined</code> in case the meta data is not (yet) available. Use{@link #requestObject
             * requestObject} for asynchronous access.
             * @since 1.37.0
             * @param sPath A relative or absolute path within the meta data model
             * @param oContext The context to be used as a starting point in case of a relative path
             * @returns The requested meta data object if it is already available, or <code>undefined</code>
            */
            getObject(sPath: string, oContext?: sap.ui.model.Context): any;

            /**
             * Method not supported
             * @since 1.37.0
            */
            getOriginalProperty(): void;

            /**
             * @since 1.37.0
            */
            getProperty(): void;

            /**
             * Returns the UI5 type for the given property path that formats and parses corresponding tothe
             * property's EDM type and constraints. The property's type must be a primitive type. Use{@link
             * #requestUI5Type requestUI5Type} for asynchronous access.
             * @since 1.37.0
             * @param sPath An absolute path to an OData property within the OData data model
             * @returns The corresponding UI5 type from <code>sap.ui.model.odata.type</code>, if all required meta 
             * data to calculate this type is already available; if no specific type can be determined, a  warning
             * is logged and <code>sap.ui.model.odata.type.Raw</code> is used
            */
            getUI5Type(sPath: string): sap.ui.model.odata.type.ODataType;

            /**
             * Method not supported
             * @since 1.37.0
            */
            isList(): void;

            /**
             * Method not supported
             * @since 1.37.0
            */
            refresh(): void;

            /**
             * Requests the meta data value for the given path relative to the given context (see{@link #resolve
             * resolve} on how this resolution happens and how slashes are inserted as aseparator). Returns a
             * <code>Promise</code> which is resolved with the requested meta datavalue or rejected with an error
             * (only in case meta data cannot be loaded). An invalid pathleads to an <code>undefined</code> result
             * and a warning is logged. Use{@link #getObject getObject} for synchronous access.The basic idea is
             * that every path described in "14.2.1 Attribute Target" in specification"OData Version 4.0 Part 3:
             * Common Schema Definition Language" is a valid absolute pathwithin the meta data model if a leading
             * slash is added; for example"/" +
             * "MySchema.MyEntityContainer/MyEntitySet/MyComplexProperty/MyNavigationProperty". Also,every path
             * described in "14.5.2 Expression edm:AnnotationPath","14.5.11 Expression edm:NavigationPropertyPath",
             * "14.5.12 Expression edm:Path", and"14.5.13 Expression edm:PropertyPath" is a valid relative path
             * within the meta data modelif a suitable prefix is added which addresses an entity container, entity
             * set, singleton,complex type, entity type, or property; for
             * example"/MySchema.MyEntityType/MyProperty" + "@vCard.Address#work/FullName".The absolute path is
             * split into segments and followed step-by-step, starting at the globalscope of all known qualified
             * OData names. There are two technical properties there:"$Version" (typically "4.0") and
             * "$EntityContainer" with the name of the single entitycontainer for this meta data model's service.An
             * empty segment in between is invalid. An empty segment at the end caused by a trailingslash
             * differentiates between a name and the object it refers to. This way,"/$EntityContainer" refers to
             * the name of the single entity container and"/$EntityContainer/" refers to the single entity
             * container as an object.The segment "@sapui.name" refers back to the last OData name (simple
             * identifier or qualifiedname) or annotation name encountered during path traversal immediately before
             * "@sapui.name":<ul><li> "/EMPLOYEES@sapui.name" results in "EMPLOYEES" and
             * "/EMPLOYEES/@sapui.name"results in the same as "/EMPLOYEES/$Type", that is, the qualified name of
             * the entity set'stype (see below how "$Type" is inserted implicitly). Note how the separating slash
             * againmakes a difference here.<li> "/EMPLOYEES/@com.sap.vocabularies.Common.v1.Label@sapui.name"
             * results in"@com.sap.vocabularies.Common.v1.Label" and a slash does not make any difference as long
             * asthe annotation does not have a "$Type" property.<li> A technical property (that is, a numerical
             * segment or one starting with a "$")immediately before "@sapui.name" is invalid, for example
             * "/$EntityContainer@sapui.name".</ul>The path must not continue after "@sapui.name".If the current
             * object is a string value, that string value is treated as a relative path andfollowed step-by-step
             * before the next segment is processed. Except for this, a path mustnot continue if it comes across a
             * non-object value. Such a string value can be a qualifiedname (example path "/$EntityContainer/..."),
             * a simple identifier (example path"/TEAMS/$NavigationPropertyBinding/TEAM_2_EMPLOYEES/...") or even a
             * path according to"14.5.12 Expression edm:Path" etc. (example
             * path"/TEAMS/$Type/@com.sap.vocabularies.UI.v1.LineItem/0/Value/$Path/...").Segments starting with an
             * "@" character, for example "@com.sap.vocabularies.Common.v1.Label",address annotations at the
             * current object. As the first segment, they refer to the singleentity container. For objects which
             * can only be annotated inline (see "14.3 Elementedm:Annotation" minus "14.2.1 Attribute Target"), the
             * object already contains theannotations as a property. For objects which can (only or also) be
             * annotated via externaltargeting, the object does not contain any annotation as a property. Such
             * annotations MUSTbe accessed via a path. BEWARE of a special case: Actions, functions and their
             * parameterscan be annotated inline for a single overload or via external targeting for all overloads
             * atthe same time. In this case, the object contains all annotations for the single overload asa
             * property, but annotations MUST nevertheless be accessed via a path in order to includealso
             * annotations for all overloads at the same time.Segments starting with an OData name followed by an
             * "@" character, for example"/TEAMS@Org.OData.Capabilities.V1.TopSupported", address annotations at an
             * entity set,singleton, or property, not at the corresponding type. In
             * contrast,"/TEAMS/@com.sap.vocabularies.Common.v1.Deletable" (note the separating slash) addresses
             * anannotation at the entity set's type. This is in line with the special rule of"14.5.12 Expression
             * edm:Path" regarding annotations at a navigation property itself."@" can be used as a segment to
             * address a map of all annotations of the current object. Thisis useful for iteration, for example
             * via<code>&lt;template:repeat list="{entityType>@}" ...></code>.Annotations of an annotation are
             * addressed not by two separate segments, but by a singlesegment
             * like"@com.sap.vocabularies.Common.v1.Text@com.sap.vocabularies.Common.v1.TextArrangement".
             * Eachannotation can have a qualifier, for example "@first#foo@second#bar". Note: If the
             * firstannotation's value is a record, a separate segment addresses an annotation of that record,not
             * an annotation of the first annotation itself.In a similar way, annotations of "7.2 Element
             * edm:ReferentialConstraint","7.3 Element edm:OnDelete", "10.2 Element edm:Member" and"14.5.14.2
             * Element edm:PropertyValue" are addressed by segments like"&lt;7.2.1 Attribute Property>@...",
             * "$OnDelete@...", "&lt;10.2.1 Attribute Name>@..." and"&lt;14.5.14.2.1 Attribute Property>@..."
             * (where angle brackets denote a variable part andsections refer to specification "OData Version 4.0
             * Part 3: Common Schema DefinitionLanguage").A segment which represents an OData qualified name is
             * looked up in the global scope ("scopelookup") and thus determines a schema child which is used later
             * on. Unknown qualified namesare invalid. This way, "/acme.DefaultContainer/EMPLOYEES" addresses the
             * "EMPLOYEES" child ofthe schema child named "acme.DefaultContainer". This also works
             * indirectly("/$EntityContainer/EMPLOYEES") and implicitly ("/EMPLOYEES", see below).A segment which
             * represents an OData simple identifier needs special preparations. The sameapplies to the empty
             * segment after a trailing slash.<ol><li> If the current object has a "$Action", "$Function" or
             * "$Type" property, it is used for   scope lookup first. This way, "/EMPLOYEES/ENTRYDATE" addresses
             * the same object as   "/EMPLOYEES/$Type/ENTRYDATE", namely the "ENTRYDATE" child of the entity type  
             * corresponding to the "EMPLOYEES" child of the entity container. The other cases jump from   an
             * action or function import to the corresponding action or function overloads.<li> Else if the segment
             * is the first one within its path, the last schema child addressed   via scope lookup is used instead
             * of the current object. This can only happen indirectly as   in
             * "/TEAMS/$NavigationPropertyBinding/TEAM_2_EMPLOYEES/..." where the schema child is the   entity
             * container and the navigation property binding can contain the simple identifier of   another entity
             * set within the same container.   If the segment is the first one overall, "$EntityContainer" is
             * inserted into the path   implicitly. In other words, the entity container is used as the initial
             * schema child.   This way, "/EMPLOYEES" addresses the same object as "/$EntityContainer/EMPLOYEES",
             * namely   the "EMPLOYEES" child of the entity container.<li> Afterwards, if the current object is an
             * array, it represents overloads for an action or   function. Multiple overloads are invalid. The
             * overload's "$ReturnType/$Type" is used for   scope lookup. This way, "/GetOldestWorker/AGE"
             * addresses the same object as   "/GetOldestWorker/0/$ReturnType/$Type/AGE". For primitive return
             * types, the special   segment "value" can be used to refer to the return type itself (see   {@link
             * sap.ui.model.odata.v4.ODataContextBinding#execute}). This way,   "/GetOldestAge/value" addresses the
             * same object as "/GetOldestAge/0/$ReturnType" (which   is needed for automatic type determination,
             * see {@link #requestUI5Type}).</ol>A trailing slash can be used to continue a path and thus force
             * scope lookup or OData simpleidentifier preparations, but then stay at the current object. This way,
             * "/EMPLOYEES/$Type/"addresses the entity type itself corresponding to the "EMPLOYEES" child of the
             * entitycontainer. Although the empty segment is not an OData simple identifier, it can be used as
             * aplaceholder for one. In this way, "/EMPLOYEES/" addresses the same entity type
             * as"/EMPLOYEES/$Type/". That entity type in turn is a map of all its OData children (that
             * is,structural and navigation properties) and determines the set of possible child names thatmight be
             * used after the trailing slash.Any other segment, including an OData simple identifier, is looked up
             * as a property of thecurrent object.
             * @since 1.37.0
             * @param sPath A relative or absolute path within the meta data model
             * @param oContext The context to be used as a starting point in case of a relative path, see  {@link
             * #resolve resolve}
             * @returns A promise which is resolved with the requested meta data value as soon as it is  available
            */
            requestObject(sPath: string, oContext?: sap.ui.model.Context): JQueryPromise<any>;

            /**
             * Requests the UI5 type for the given property path that formats and parses corresponding tothe
             * property's EDM type and constraints. The property's type must be a primitive type. Use{@link
             * #getUI5Type getUI5Type} for synchronous access.
             * @since 1.37.0
             * @param sPath An absolute path to an OData property within the OData data model
             * @returns A promise that gets resolved with the corresponding UI5 type from 
             * <code>sap.ui.model.odata.type</code> or rejected with an error; if no specific type can be 
             * determined, a warning is logged and <code>sap.ui.model.odata.type.Raw</code> is used
            */
            requestUI5Type(sPath: string): JQueryPromise<any>;

            /**
             * Method not supported
             * @since 1.37.0
            */
            setLegacySyntax(): void;

            /**
             * Returns a string representation of this object including the URL to the $metadata document ofthe
             * service.
             * @since 1.37.0
             * @returns A string description of this model
            */
            toString(): string;
          }
          /**
           * List binding for an OData V4 model.  An event handler can only be attached to this binding for the
           * following events: 'change',  'dataReceived', 'dataRequested', and 'refresh'.  For other events, an
           * error is thrown.
           * @resource sap/ui/model/odata/v4/ODataListBinding.js
          */
          export class ODataListBinding extends sap.ui.model.ListBinding {


            /**
             * DO NOT CALL this private constructor for a new <code>ODataListBinding</code>,but rather use {@link
             * sap.ui.model.odata.v4.ODataModel#bindList bindList} instead!
             * @param oModel The OData V4 model
             * @param sPath The binding path in the model; must not be empty or end with a slash
             * @param oContext The parent context which is required as base for a relative path
             * @param vSorters The dynamic sorters to be used initially. Call {@link #sort} to replace them. Static
             *  sorters, as defined in the '$orderby' binding parameter, are always executed after the  dynamic
             * sorters.  Supported since 1.39.0.
             * @param vFilters The dynamic application filters to be used initially. Call {@link #filter} to
             * replace them.  Static filters, as defined in the '$filter' binding parameter, are always combined
             * with the  dynamic filters using a logical <code>AND</code>.  Supported since 1.39.0.
             * @param mParameters Map of binding parameters which can be OData query options as specified in 
             * "OData Version 4.0 Part 2: URL Conventions" or the binding-specific parameters "$$groupId"  and
             * "$$updateGroupId".  Note: If parameters are provided for a relative binding path, the binding
             * accesses data  with its own service requests instead of using its parent binding.  The following
             * OData query options are allowed:  <ul>  <li> All "5.2 Custom Query Options" except for those with a
             * name starting with "sap-"  <li> The $expand, $filter, $orderby and $select "5.1 System Query
             * Options"  </ul>  All other query options lead to an error.  Query options specified for the binding
             * overwrite model query options.
            */
            constructor(oModel: sap.ui.model.odata.v4.ODataModel, sPath: string, oContext?: sap.ui.model.odata.v4.Context, vSorters?: sap.ui.model.Sorter | sap.ui.model.Sorter[], vFilters?: sap.ui.model.Filter | sap.ui.model.Filter[], mParameters?: any);



            /**
             * Destroys the object. The object must not be used anymore after this function was called.
             * @since 1.40.1
            */
            destroy(bSuppressInvalidate: boolean): void;


            /**
             * Filters the list with the given filters.If there are pending changes an error is thrown. Use {@link
             * #hasPendingChanges} to check ifthere are pending changes. If there are changes, call{@link
             * sap.ui.model.odata.v4.ODataModel#submitBatch} to submit the changes or{@link
             * sap.ui.model.odata.v4.ODataModel#resetChanges} to reset the changes before calling'filter'.
             * @since 1.39.0
             * @param vFilters The dynamic filters to be used; replaces the dynamic filters given in  {@link
             * sap.ui.model.odata.v4.ODataModel#bindList}.  The filter executed on the list is created from the
             * following parts, which are combined  with a logical 'and':  <ul>  <li> dynamic filters of type
             * sap.ui.model.FilterType.Application  <li> dynamic filters of type sap.ui.model.FilterType.Control 
             * <li> the static filters, as defined in the '$filter' binding parameter  </ul>
             * @param sFilterType The filter type to use
             * @returns <code>this</code> to facilitate method chaining
            */
            filter(vFilters: sap.ui.model.Filter | sap.ui.model.Filter[], sFilterType?: typeof sap.ui.model.FilterType): sap.ui.model.odata.v4.ODataListBinding;

            /**
             * Returns already created binding contexts for all entities in this list binding for the
             * rangedetermined by the given start index <code>iStart</code> and <code>iLength</code>.If at least
             * one of the entities in the given range has not yet been loaded, fires a{@link
             * sap.ui.model.Binding#attachChange 'change'} event on this list binding once theseentities have been
             * loaded <b>asynchronously</b>. A further call to this method in the'change' event handler with the
             * same index range then yields the updated array of contexts.
             * @since 1.37.0
             * @param iStart The index where to start the retrieval of contexts
             * @param iLength The number of contexts to retrieve beginning from the start index; defaults to the
             * model's  size limit, see {@link sap.ui.model.Model#setSizeLimit}
             * @param iMaximumPrefetchSize The maximum number of contexts to read before and after the given range;
             * with this,  controls can prefetch data that is likely to be needed soon, e.g. when scrolling down in
             * a  table. Negative values will be treated as 0.
             * @returns The array of already created contexts with the first entry containing the context for 
             * <code>iStart</code>
            */
            getContexts(iStart: number, iLength?: number, iMaximumPrefetchSize?: number): sap.ui.model.odata.v4.Context[];

            /**
             * Returns the contexts that were requested by a control last time. Does not trigger adata request. In
             * the time between the {@link #event:dataRequested dataRequested} event andthe {@link
             * #event:dataReceived dataReceived} event, the resulting array contains<code>undefined</code> at those
             * indexes where the data is not yet available.
             * @since 1.39.0
             * @returns The contexts
            */
            getCurrentContexts(): sap.ui.model.odata.v4.Context[];

            /**
             * Method not supported
             * @since 1.37.0
            */
            getDistinctValues(sPath?: string): any[];

            /**
             * Returns the number of entries in the list. As long as the client does not know the size onthe server
             * an estimated length is returned.
             * @since 1.37.0
             * @returns The number of entries in the list
            */
            getLength(): number;

            /**
             * Returns a metadata object for class sap.ui.model.odata.v4.ODataListBinding.
             * @returns Metadata object describing this class
            */
            getMetadata(): sap.ui.base.Metadata;

            /**
             * Returns <code>true</code> if the binding has pending changes, meaning updates via two-waybinding
             * that have not yet been sent to the server.
             * @since 1.39.0
             * @returns <code>true</code> if the binding has pending changes
            */
            hasPendingChanges(): boolean;

            /**
             * Initializes the OData list binding. Fires a 'change' event in case the binding has aresolved path.
             * @since 1.37.0
            */
            initialize(): void;

            /**
             * Method not supported
             * @since 1.37.0
            */
            isInitial(): boolean;

            /**
             * Returns <code>true</code> if the length has been determined by the data returned fromserver. If the
             * length is a client side estimation <code>false</code> is returned.
             * @since 1.37.0
             * @returns If <code>true</true> the length is determined by server side data
            */
            isLengthFinal(): boolean;

            /**
             * Refreshes the binding. Prompts the model to retrieve data from the server using the givengroup ID
             * and notifies the control that new data is available.Refresh is supported for absolute bindings.Note:
             * When calling refresh multiple times, the result of the request triggered by the lastcall determines
             * the binding's data; it is <b>independent</b>of the order of calls to {@link
             * sap.ui.model.odata.v4.ODataModel#submitBatch} with the givengroup ID.
             * @since 1.37.0
             * @param sGroupId The group ID to be used for refresh; if not specified, the group ID for this binding
             * is  used, see {@link sap.ui.model.odata.v4.ODataListBinding#constructor}.  Valid values are
             * <code>undefined</code>, <code>'$auto'</code>, <code>'$direct'</code> or  application group IDs as
             * specified in {@link sap.ui.model.odata.v4.ODataModel#submitBatch}.
            */
            refresh(sGroupIdOrForceUpdate: string | boolean): void;

            /**
             * Resets all pending property changes of this binding, meaning updates via two-way binding thathave
             * not yet been sent to the server.
             * @since 1.40.1
            */
            resetChanges(): void;

            /**
             * Method not supported
             * @since 1.37.0
            */
            resume(): void;

            /**
             * Sort the entries represented by this list binding according to the given sorters.The sorters are
             * stored at this list binding and they are used for each following datarequest.If there are pending
             * changes an error is thrown. Use {@link #hasPendingChanges} to check ifthere are pending changes. If
             * there are changes, call{@link sap.ui.model.odata.v4.ODataModel#submitBatch) to submit the changes
             * or{@link sap.ui.model.odata.v4.ODataModel#resetChanges} to reset the changes before calling'sort'.
             * @since 1.39.0
             * @param vSorters The dynamic sorters to be used; they replace the dynamic sorters given in  {@link
             * sap.ui.model.odata.v4.ODataModel#bindList}.  Static sorters, as defined in the '$orderby' binding
             * parameter, are always executed after  the dynamic sorters.
             * @returns <code>this</code> to facilitate method chaining
            */
            sort(vSorters: sap.ui.model.Sorter | sap.ui.model.Sorter[]): sap.ui.model.odata.v4.ODataListBinding;

            /**
             * Method not supported
             * @since 1.37.0
            */
            suspend(): void;

            /**
             * Returns a string representation of this object including the binding path. If the binding
             * isrelative, the parent path is also given, separated by a '|'.
             * @since 1.37.0
             * @returns A string description of this binding
            */
            toString(): string;
          }
          /**
           * Context binding for an OData V4 model.  An event handler can only be attached to this binding for
           * the following events: 'change',  'dataReceived', and 'dataRequested'.  For other events, an error is
           * thrown.  A context binding can also be used as an <i>operation binding</i> to support bound actions,
           *  action imports and function imports. If you want to control the execution time of an  operation,
           * for example a function import named "GetNumberOfAvailableItems", create a  context binding for the
           * path "/GetNumberOfAvailableItems(...)" (as specified here,  including the three dots). Such an
           * operation binding is <i>deferred</i>, meaning that it  does not request automatically, but only when
           * you call {@link #execute}. {@link #refresh}  is always ignored for actions and action imports. For
           * function imports, it is ignored if  {@link #execute} has not yet been called. Afterwards it results
           * in another call of the  function with the parameter values of the last execute.  The binding
           * parameter for bound actions may be given in the binding path, for example 
           * <code>/TEAMS(Team_Id='TEAM_01')/tea_busi.AcChangeManagerOfTeam(...)</code>. This can be  used if the
           * exact instance is known in advance. If you use a relative binding instead, the  operation path is a
           * concatenation of the parent context's canonical path and the deferred  binding's path. 
           * <b>Example</b>: You have a table with a list binding to <code>/TEAMS</code>. In each row  you have a
           * button to change the team's manager, with the relative binding 
           * <code>tea_busi.AcChangeManagerOfTeam(...)</code>. Then the parent context for such a button  refers
           * to an instance of TEAMS, so its canonical path is  <code>/TEAMS(ID='<i>TeamID</i>')</code> and the
           * resulting path for the action is 
           * <code>/TEAMS(ID='<i>TeamID</i>')/tea_busi.AcChangeManagerOfTeam</code>.  This also works if the
           * relative path of the deferred operation binding starts with a  navigation property. Then this
           * navigation property will be part of the operation's  resource path, which is still valid.  A
           * deferred operation binding is not allowed to have another deferred operation binding as  parent.
           * @resource sap/ui/model/odata/v4/ODataContextBinding.js
          */
          export class ODataContextBinding extends sap.ui.model.ContextBinding {

            /**
             * Returns the bound context.
             * @since 1.39.0
            */
            public getBoundContext: any;


            /**
             * DO NOT CALL this private constructor for a new <code>ODataContextBinding</code>,but rather use
             * {@link sap.ui.model.odata.v4.ODataModel#bindContext bindContext} instead!
             * @param oModel The OData V4 model
             * @param sPath The binding path in the model; must not end with a slash
             * @param oContext The context which is required as base for a relative path
             * @param mParameters Map of binding parameters which can be OData query options as specified in 
             * "OData Version 4.0 Part 2: URL Conventions" or the binding-specific parameters "$$groupId"  and
             * "$$updateGroupId".  Note: If parameters are provided for a relative binding path, the binding
             * accesses data  with its own service requests instead of using its parent binding.  The following
             * OData query options are allowed:  <ul>  <li> All "5.2 Custom Query Options" except for those with a
             * name starting with "sap-"  <li> The $expand, $filter, $orderby and $select "5.1 System Query
             * Options"; OData V4 only  allows $filter and $orderby inside resource paths that identify a
             * collection. In our case  here, this means you can only use them inside $expand.  </ul>  All other
             * query options lead to an error.  Query options specified for the binding overwrite model query
             * options.
            */
            constructor(oModel: sap.ui.model.odata.v4.ODataModel, sPath: string, oContext?: sap.ui.model.odata.v4.Context, mParameters?: any);



            /**
             * Destroys the object. The object must not be used anymore after this function was called.
             * @since 1.40.1
            */
            destroy(bSuppressInvalidate: boolean): void;

            /**
             * Calls the OData operation that corresponds to this operation binding.Parameters for the operation
             * must be set via {@link #setParameter} beforehand.The value of this binding is the result of the
             * operation. To access a result of primitivetype, bind a control to the path "value", for
             * example<code>&lt;Text text="{value}"/&gt;</code>. If the result has a complex or entity type, youcan
             * bind properties as usual, for example <code>&lt;Text text="{street}"/&gt;</code>.
             * @since 1.37.0
             * @param sGroupId The group ID to be used for the request; if not specified, the group ID for this
             * binding is  used, see {@link sap.ui.model.odata.v4.ODataContextBinding#constructor}.  Valid values
             * are <code>undefined</code>, <code>'$auto'</code>, <code>'$direct'</code> or  application group IDs
             * as specified in {@link sap.ui.model.odata.v4.ODataModel#submitBatch}.
             * @returns A promise that is resolved without data when the operation call succeeded, or rejected 
             * with an instance of <code>Error</code> in case of failure.
            */
            execute(sGroupId: string): JQueryPromise<any>;


            /**
             * Returns a metadata object for class sap.ui.model.odata.v4.ODataContextBinding.
             * @returns Metadata object describing this class
            */
            getMetadata(): sap.ui.base.Metadata;

            /**
             * Returns <code>true</code> if the binding has pending changes, meaning updates via two-waybinding
             * that have not yet been sent to the server.
             * @since 1.39.0
             * @returns <code>true</code> if the binding has pending changes
            */
            hasPendingChanges(): boolean;

            /**
             * Initializes the OData context binding. Fires a 'change' event in case the binding has abound
             * context.
             * @since 1.37.0
            */
            initialize(): void;

            /**
             * Method not supported
             * @since 1.37.0
            */
            isInitial(): boolean;

            /**
             * Refreshes the binding. Prompts the model to retrieve data from the server using the givengroup ID
             * and notifies the control that new data is available.Refresh is supported for absolute bindings.Note:
             * When calling refresh multiple times, the result of the request triggered by the lastcall determines
             * the binding's data; it is <b>independent</b>of the order of calls to {@link
             * sap.ui.model.odata.v4.ODataModel#submitBatch} with the givengroup ID.
             * @since 1.37.0
             * @param sGroupId The group ID to be used for refresh; if not specified, the group ID for this binding
             * is  used, see {@link sap.ui.model.odata.v4.ODataContextBinding#constructor}.  Valid values are
             * <code>undefined</code>, <code>'$auto'</code>, <code>'$direct'</code> or  application group IDs as
             * specified in {@link sap.ui.model.odata.v4.ODataModel#submitBatch}.
            */
            refresh(sGroupIdOrForceUpdate: string | boolean): void;

            /**
             * Resets all pending property changes of this binding, meaning updates via two-way binding thathave
             * not yet been sent to the server.
             * @since 1.40.1
            */
            resetChanges(): void;

            /**
             * Method not supported
             * @since 1.37.0
            */
            resume(): void;

            /**
             * Sets a parameter for an operation call.
             * @since 1.37.0
             * @param sParameterName The parameter name
             * @param vValue The parameter value
             * @returns <code>this</code> to enable method chaining
            */
            setParameter(sParameterName: string, vValue: any): sap.ui.model.odata.v4.ODataContextBinding;

            /**
             * Method not supported
             * @since 1.37.0
            */
            suspend(): void;

            /**
             * Returns a string representation of this object including the binding path. If the binding
             * isrelative, the parent path is also given, separated by a '|'.
             * @since 1.37.0
             * @returns A string description of this binding
            */
            toString(): string;
          }
          /**
           * Property binding for an OData V4 model.  An event handler can only be attached to this binding for
           * the following events: 'change',  'dataReceived', and 'dataRequested'.  For other events, an error is
           * thrown.
           * @resource sap/ui/model/odata/v4/ODataPropertyBinding.js
          */
          export class ODataPropertyBinding extends sap.ui.model.PropertyBinding {


            /**
             * DO NOT CALL this private constructor for a new <code>ODataPropertyBinding</code>,but rather use
             * {@link sap.ui.model.odata.v4.ODataModel#bindProperty bindProperty} instead!
             * @param oModel The OData V4 model
             * @param sPath The binding path in the model; must not be empty or end with a slash
             * @param oContext The context which is required as base for a relative path
             * @param mParameters Map of binding parameters which can be OData query options as specified in 
             * "OData Version 4.0 Part 2: URL Conventions" or the binding-specific parameters "$$groupId"  and
             * "$$updateGroupId".  Note: Binding parameters may only be provided for absolute binding paths as only
             * those  lead to a data service request.  All "5.2 Custom Query Options" are allowed except for those
             * with a name starting with  "sap-". All other query options lead to an error.  Query options
             * specified for the binding overwrite model query options.
            */
            constructor(oModel: sap.ui.model.odata.v4.ODataModel, sPath: string, oContext?: sap.ui.model.odata.v4.Context, mParameters?: any);



            /**
             * Destroys the object. The object must not be used anymore after this function was called.
             * @since 1.39.0
            */
            destroy(bSuppressInvalidate: boolean): void;

            /**
             * Returns the current value.
             * @since 1.37.0
             * @returns The current value
            */
            getValue(): any;

            /**
             * Returns <code>true</code> if the binding has pending changes, that is updates via two-waybinding
             * that have not yet been sent to the server.
             * @since 1.39.0
             * @returns <code>true</code> if the binding has pending changes
            */
            hasPendingChanges(): boolean;

            /**
             * Method not supported
             * @since 1.37.0
            */
            isInitial(): boolean;

            /**
             * Refreshes this binding; refresh is supported for absolute bindings only.A refresh retrieves data
             * from the server using the given group ID and fires a change eventwhen new data is available.Note:
             * When calling refresh multiple times, the result of the request triggered by the lastcall determines
             * the binding's data; it is <b>independent</b>of the order of calls to {@link
             * sap.ui.model.odata.v4.ODataModel#submitBatch} with the givengroup ID.
             * @since 1.37.0
             * @param sGroupId The group ID to be used for refresh; if not specified, the group ID for this binding
             * is  used, see {@link sap.ui.model.odata.v4.ODataPropertyBinding#constructor}.  Valid values are
             * <code>undefined</code>, <code>'$auto'</code>, <code>'$direct'</code> or  application group IDs as
             * specified in {@link sap.ui.model.odata.v4.ODataModel#submitBatch}.
            */
            refresh(sGroupIdOrForceUpdate: string | boolean): void;

            /**
             * Method not supported
             * @since 1.37.0
            */
            resume(): void;

            /**
             * Sets the optional type and internal type for this binding; used for formatting and parsing.Fires a
             * change event if the type has changed.
             * @param oType The type for this binding
             * @param sInternalType The internal type of the element property which owns this binding, for example
             * "any",  "boolean", "float", "int", "string"; see {@link sap.ui.model.odata.type} for more 
             * information
            */
            setType(oType: sap.ui.model.Type, sInternalType: string): void;

            /**
             * Sets the new current value and updates the cache.
             * @since 1.37.0
             * @param vValue The new value which must be primitive
             * @param sGroupId The group ID to be used for this update call; if not specified, the update group ID
             * for  this binding (or its relevant parent binding) is used, see  {@link
             * sap.ui.model.odata.v4.ODataPropertyBinding#constructor}.  Valid values are <code>undefined</code>,
             * <code>'$auto'</code>, <code>'$direct'</code> or  application group IDs as specified in {@link
             * sap.ui.model.odata.v4.ODataModel#submitBatch}.
            */
            setValue(vValue: any, sGroupId?: string): void;

            /**
             * Method not supported
             * @since 1.37.0
            */
            suspend(): void;

            /**
             * Returns a string representation of this object including the binding path. If the binding
             * isrelative, the parent path is also given, separated by a '|'.
             * @since 1.37.0
             * @returns A string description of this binding
            */
            toString(): string;
          }
        }
        namespace v2 {
          namespace ODataAnnotations {
            /**
             * @resource sap/ui/model/odata/v2/ODataAnnotations.js
            */
            export class constructor {


              /**
               * Creates a new instance of the ODataAnnotations annotation loader.
               * @param oMetadata Metadata object with the metadata information needed to parse the annotations
               * @param mOptions Obligatory options
              */
              constructor(oMetadata: sap.ui.model.odata.ODataMetadata, mOptions: any);


            }
          }
          /**
           * Model implementation for oData format
           * @resource sap/ui/model/odata/v2/ODataModel.js
          */
          export class ODataModel extends sap.ui.model.Model {


            /**
             * Constructor for a new ODataModel.
             * @param sServiceUrl base uri of the service to request data from; additional URL parameters appended
             * here will be appended to every request								can be passed with the mParameters object as well:
             * [mParameters.serviceUrl] A serviceURl is required!
             * @param mParameters (optional) a map which contains the following parameter properties:
            */
            constructor(sServiceUrl: string, mParameters?: any);



            /**
             * Adds (a) new URL(s) to the be parsed for OData annotations, which are then merged into the
             * annotations objectwhich can be retrieved by calling the getServiceAnnotations()-method. If a
             * $metadata url is passed the data willalso be merged into the metadata object, which can be reached
             * by calling the getServiceMetadata() method.
             * @param vUrl Either one URL as string or an array or URL strings
             * @returns The Promise to load the given URL(s), resolved if all URLs have been loaded, rejected if at
             * least one fails to load.					 If this promise resolves it returns the following parameters:					
             * annotations: The annotation object					 entitySets: An array of EntitySet objects containing the
             * newly merged EntitySets from a $metadata requests.								 the structure is the same as in the
             * metadata object reached by the getServiceMetadata() method.								 For non $metadata requests the
             * array will be empty.
            */
            addAnnotationUrl(vUrl: string | string[]): JQueryPromise<any>;

            /**
             * Adds new xml content to be parsed for OData annotations, which are then merged into the annotations
             * object whichcan be retrieved by calling the getServiceAnnotations()-method.
             * @param sXMLContent The string that should be parsed as annotation XML
             * @param bSuppressEvents Whether not to fire annotationsLoaded event on the annotationParser
             * @returns The Promise to parse the given XML-String, resolved if parsed without errors, rejected if
             * errors occur
            */
            addAnnotationXML(sXMLContent: string, bSuppressEvents?: boolean): JQueryPromise<any>;

            /**
             * Attach event-handler <code>fnFunction</code> to the 'annotationsFailed' event of this
             * <code>sap.ui.model.odata.v2.ODataModel</code>.
             * @param oData The object, that should be passed along with the event-object when firing the event.
             * @param fnFunction The function to call, when the event occurs. This function will be called on the  
             *         oListener-instance (if present) or in a 'static way'.
             * @param oListener Object on which to call the given function. If empty, the global context (window)
             * is used.
             * @returns <code>this</code> to allow method chaining
            */
            attachAnnotationsFailed(oData: any, fnFunction: any, oListener?: any): sap.ui.model.odata.v2.ODataModel;

            /**
             * Attach event-handler <code>fnFunction</code> to the 'annotationsLoaded' event of this
             * <code>sap.ui.model.odata.v2.ODataModel</code>.
             * @param oData The object, that should be passed along with the event-object when firing the event.
             * @param fnFunction The function to call, when the event occurs. This function will be called on the  
             *         oListener-instance (if present) or in a 'static way'.
             * @param oListener Object on which to call the given function. If empty, the global context (window)
             * is used.
             * @returns <code>this</code> to allow method chaining
            */
            attachAnnotationsLoaded(oData: any, fnFunction: any, oListener?: any): sap.ui.model.odata.v2.ODataModel;

            /**
             * Attach event-handler <code>fnFunction</code> to the 'batchRequestCompleted' event of this
             * <code>sap.ui.model.odata.v2.ODataModel</code>.
             * @param oData The object, that should be passed along with the event-object when firing the event.
             * @param fnFunction The function to call, when the event occurs. This function will be called on the  
             *         oListener-instance (if present) or in a 'static way'.
             * @param oListener Object on which to call the given function. If empty, the global context (window)
             * is used.
             * @returns <code>this</code> to allow method chaining
            */
            attachBatchRequestCompleted(oData: any, fnFunction: any, oListener?: any): sap.ui.model.odata.v2.ODataModel;

            /**
             * Attach event-handler <code>fnFunction</code> to the 'batchRequestFailed' event of this
             * <code>sap.ui.model.odata.v2.ODataModel</code>.<br/>
             * @param oData The object, that should be passed along with the event-object when firing the event.
             * @param fnFunction The function to call, when the event occurs. This function will be called on the  
             *         oListener-instance (if present) or in a 'static way'.
             * @param oListener Object on which to call the given function. If empty, this Model is used.
             * @returns <code>this</code> to allow method chaining
            */
            attachBatchRequestFailed(oData: any, fnFunction: any, oListener?: any): sap.ui.model.odata.v2.ODataModel;

            /**
             * Attach event-handler <code>fnFunction</code> to the 'requestSent' event of this
             * <code>sap.ui.model.odata.v2.ODataModel</code>.
             * @param oData The object, that should be passed along with the event-object when firing the event.
             * @param fnFunction The function to call, when the event occurs. This function will be called on the  
             *         oListener-instance (if present) or in a 'static way'.
             * @param oListener Object on which to call the given function. If empty, the global context (window)
             * is used.
             * @returns <code>this</code> to allow method chaining
            */
            attachBatchRequestSent(oData: any, fnFunction: any, oListener?: any): sap.ui.model.odata.v2.ODataModel;

            /**
             * Attach event-handler <code>fnFunction</code> to the 'metadataFailed' event of this
             * <code>sap.ui.model.odata.v2.ODataModel</code>.
             * @param oData The object, that should be passed along with the event-object when firing the event.
             * @param fnFunction The function to call, when the event occurs. This function will be called on the  
             *         oListener-instance (if present) or in a 'static way'.
             * @param oListener Object on which to call the given function. If empty, the global context (window)
             * is used.
             * @returns <code>this</code> to allow method chaining
            */
            attachMetadataFailed(oData: any, fnFunction: any, oListener?: any): sap.ui.model.odata.v2.ODataModel;

            /**
             * Attach event-handler <code>fnFunction</code> to the 'metadataLoaded' event of this
             * <code>sap.ui.model.odata.v2.ODataModel</code>.
             * @param oData The object, that should be passed along with the event-object when firing the event.
             * @param fnFunction The function to call, when the event occurs. This function will be called on the  
             *         oListener-instance (if present) or in a 'static way'.
             * @param oListener Object on which to call the given function. If empty, the global context (window)
             * is used.
             * @returns <code>this</code> to allow method chaining
            */
            attachMetadataLoaded(oData: any, fnFunction: any, oListener?: any): sap.ui.model.odata.v2.ODataModel;

            /**
             * Trigger a request to the function import odata service that was specified in the model
             * constructor.If the ReturnType of the function import is either an EntityType or a collection of
             * EntityType thechanges are reflected in the model, otherwise they are ignored, and the
             * <code>response</code> canbe processed in the successHandler.
             * @param sFunctionName A string containing the name of the function to call. The name is concatenated
             * to the sServiceUrl which was       specified in the model constructor.
             * @param mParameters Optional parameter map containing any of the following properties:
             * @returns oRequestHandle An object which has a <code>contextCreated</code> function that returns a
             * <code>Promise</code>.        This resolves with the created {@link sap.ui.model.Context}.        In
             * addition it has an <code>abort</code> function to abort the current request.
            */
            callFunction(sFunctionName: string, mParameters?: any): any;

            /**
             * Trigger a POST request to the odata service that was specified in the model constructor. Please note
             * that deep creates are not supportedand may not work.
             * @param sPath A string containing the path to the collection where an entry		should be created. The
             * path is concatenated to the sServiceUrl		which was specified in the model constructor.
             * @param oData data of the entry that should be created.
             * @param mParameters Optional parameter map containing any of the following properties:
             * @returns an object which has an <code>abort</code> function to abort the current request.
            */
            create(sPath: string, oData: any, mParameters?: any): any;

            /**
             * Creates a binding context for the given pathIf the data of the context is not yet available, it can
             * not be created, but first theentity needs to be fetched from the server asynchronously. In case no
             * callback functionis provided, the request will not be triggered.
             * @param sPath binding path
             * @param oContext bindingContext
             * @param mParameters a map which contains additional parameters for the binding
             * @param fnCallBack function called when context is created
             * @param bReload reload of data
            */
            createBindingContext(sPath: string, oContext?: any, mParameters?: any, fnCallBack?: any, bReload?: boolean): sap.ui.model.Context;

            /**
             * Creates a new entry object which is described by the metadata of the entity type of thespecified
             * sPath Name. A context object is returned which can be used to bindagainst the newly created
             * object.For each created entry a request is created and stored in a request queue.The request queue
             * can be submitted by calling submitChanges. To delete a createdentry from the request queue call
             * deleteCreatedEntry.The optional properties parameter can be used as follows:  - properties could be
             * an array containing the property names which should be included    in the new entry. Other
             * properties defined in the entity type are not included.  - properties could be an object which
             * includes the desired properties and the values    which should be used for the created entry.If
             * properties is not specified, all properties in the entity type will be included in thecreated
             * entry.If there are no values specified the properties will have undefined values.Please note that
             * deep creates (including data defined by navigationproperties) are not supported
             * @param sPath Name of the path to the EntitySet
             * @param mParameters A map of the following parameters:
             * @returns oContext A Context object that point to the new created entry.
            */
            createEntry(sPath: String, mParameters: any): sap.ui.model.Context;

            /**
             * Creates the key from the given collection name and property map. Please make sure that the metadata
             * document is loaded before using this function.
             * @param sCollection The name of the collection
             * @param oKeyProperties The object containing at least all the key properties of the entity type
             * @returns [sKey] key of the entry
            */
            createKey(sCollection: string, oKeyProperties: any): string;

            /**
             * Deletes a created entry from the request queue and the model.
             * @param oContext The context object pointing to the created entry
            */
            deleteCreatedEntry(oContext: sap.ui.model.Context): void;

            /**
            */
            destroy(bSuppressInvalidate: boolean): void;

            /**
             * Detach event-handler <code>fnFunction</code> from the 'annotationsFailed' event of this
             * <code>sap.ui.model.odata.v2.ODataModel</code>.The passed function and listener object must match the
             * ones previously used for event registration.
             * @param fnFunction The function to call, when the event occurs.
             * @param oListener Object on which the given function had to be called.
             * @returns <code>this</code> to allow method chaining
            */
            detachAnnotationsFailed(fnFunction: any, oListener: any): sap.ui.model.odata.v2.ODataModel;

            /**
             * Detach event-handler <code>fnFunction</code> from the 'annotationsLoaded' event of this
             * <code>sap.ui.model.odata.v2.ODataModel</code>.
             * @param fnFunction The function to call, when the event occurs.
             * @param oListener Object on which the given function had to be called.
             * @returns <code>this</code> to allow method chaining
            */
            detachAnnotationsLoaded(fnFunction: any, oListener: any): sap.ui.model.odata.v2.ODataModel;

            /**
             * Detach event-handler <code>fnFunction</code> from the 'batchRequestCompleted' event of this
             * <code>sap.ui.model.odata.v2.ODataModel</code>.The passed function and listener object must match the
             * ones previously used for event registration.
             * @param fnFunction The function to call, when the event occurs.
             * @param oListener Object on which the given function had to be called.
             * @returns <code>this</code> to allow method chaining
            */
            detachBatchRequestCompleted(fnFunction: any, oListener: any): sap.ui.model.odata.v2.ODataModel;

            /**
             * Detach event-handler <code>fnFunction</code> from the 'batchRequestFailed' event of this
             * <code>sap.ui.model.odata.v2.ODataModel</code>.<br/>The passed function and listener object must
             * match the ones previously used for event registration.
             * @param fnFunction The function to call, when the event occurs.
             * @param oListener Object on which the given function had to be called.
             * @returns <code>this</code> to allow method chaining
            */
            detachBatchRequestFailed(fnFunction: any, oListener: any): sap.ui.model.odata.v2.ODataModel;

            /**
             * Detach event-handler <code>fnFunction</code> from the 'batchRequestSent' event of this
             * <code>sap.ui.model.odata.v2.ODataModel</code>.The passed function and listener object must match the
             * ones previously used for event registration.
             * @param fnFunction The function to call, when the event occurs.
             * @param oListener Object on which the given function had to be called.
             * @returns <code>this</code> to allow method chaining
            */
            detachBatchRequestSent(fnFunction: any, oListener: any): sap.ui.model.odata.v2.ODataModel;

            /**
             * Detach event-handler <code>fnFunction</code> from the 'metadataFailed' event of this
             * <code>sap.ui.model.odata.v2.ODataModel</code>.The passed function and listener object must match the
             * ones previously used for event registration.
             * @param fnFunction The function to call, when the event occurs.
             * @param oListener Object on which the given function had to be called.
             * @returns <code>this</code> to allow method chaining
            */
            detachMetadataFailed(fnFunction: any, oListener: any): sap.ui.model.odata.v2.ODataModel;

            /**
             * Detach event-handler <code>fnFunction</code> from the 'metadataLoaded' event of this
             * <code>sap.ui.model.odata.v2.ODataModel</code>.The passed function and listener object must match the
             * ones previously used for event registration.
             * @param fnFunction The function to call, when the event occurs.
             * @param oListener Object on which the given function had to be called.
             * @returns <code>this</code> to allow method chaining
            */
            detachMetadataLoaded(fnFunction: any, oListener: any): sap.ui.model.odata.v2.ODataModel;


            /**
             * Fire event annotationsFailed to attached listeners.
             * @param mArguments the arguments to pass along with the event.
             * @returns <code>this</code> to allow method chaining
            */
            fireAnnotationsFailed(mArguments: any): sap.ui.model.odata.v2.ODataModel;

            /**
             * Fire event annotationsLoaded to attached listeners.
             * @param mArguments the arguments to pass along with the event.
             * @returns <code>this</code> to allow method chaining
            */
            fireAnnotationsLoaded(mArguments: any): sap.ui.model.odata.v2.ODataModel;

            /**
             * Fire event batchRequestCompleted to attached listeners.
             * @param mArguments parameters to add to the fired event
             * @returns <code>this</code> to allow method chaining
            */
            fireBatchRequestCompleted(mArguments: any): sap.ui.model.odata.v2.ODataModel;

            /**
             * Fire event batchRequestFailed to attached listeners.
             * @param mArguments the arguments to pass along with the event.
             * @returns <code>this</code> to allow method chaining
            */
            fireBatchRequestFailed(mArguments: any): sap.ui.model.odata.v2.ODataModel;

            /**
             * Fire event batchRequestSent to attached listeners.
             * @param mArguments the arguments to pass along with the event.
             * @returns <code>this</code> to allow method chaining
            */
            fireBatchRequestSent(mArguments: any): sap.ui.model.odata.v2.ODataModel;

            /**
             * Fire event metadataFailed to attached listeners.
             * @param mArguments the arguments to pass along with the event.
             * @returns <code>this</code> to allow method chaining
            */
            fireMetadataFailed(mArguments: any): sap.ui.model.odata.v2.ODataModel;

            /**
             * Fire event metadataLoaded to attached listeners.
             * @param mArguments the arguments to pass along with the event.
             * @returns <code>this</code> to allow method chaining
            */
            fireMetadataLoaded(mArguments: any): sap.ui.model.odata.v2.ODataModel;

            /**
             * Force the update on the server of an entity by setting its ETag to '*'.ETag handling must be active
             * so the force update will work.
             * @param sKey The key to an Entity e.g.: Customer(4711)
            */
            forceEntityUpdate(sKey: string): void;

            /**
             * Returns the definition of batchGroups per EntityType for TwoWay changes
             * @returns mChangeBatchGroups Definition of bactchGRoups for "TwoWay" changes
            */
            getChangeBatchGroups(): any;

            /**
             * Returns the definition of groups per EntityType for TwoWay changes
             * @returns mChangeGroups Definition of Groups for "TwoWay" changes
            */
            getChangeGroups(): any;

            /**
             * Return requested data as object if the data has already been loaded and stored in the model.
             * @param sPath A string containing the path to the data object that should be returned.
             * @param oContext the optional context which is used with the sPath to retrieve the requested data.
             * @param bIncludeExpandEntries This parameter should be set when a URI or custom parameterwith a
             * $expand System Query Option was used to retrieve associated entries embedded/inline.If true then the
             * getProperty function returns a desired property value/entry and includes the associated expand
             * entries (if any).If false the associated/expanded entry properties are removed and not included in
             * thedesired entry as properties at all. This is useful for performing updates on the base entry only.
             * Note: A copy and not a reference of the entry will be returned.
             * @returns oData Object containing the requested data if the path is valid.
            */
            getData(sPath: string, oContext?: any, bIncludeExpandEntries?: boolean): any;

            /**
             * Returns the default count mode for retrieving the count of collections
             * @since 1.20
             * @returns sCountMode returns defaultCountMode
            */
            getDefaultCountMode(): typeof sap.ui.model.odata.CountMode;

            /**
             * Returns the array of batchGroupIds that are set as deferred
             * @returns aGroupIds The array of deferred batchGroupIds
            */
            getDeferredBatchGroups(): any[];

            /**
             * Returns the array of GroupIds that are set as deferred
             * @returns aGroupIds The array of deferred GroupIds
            */
            getDeferredGroups(): any[];

            /**
             * Returns the ETag for a given binding path/context or data object
             * @param sPath The binding path
             * @param oContext The binding context
             * @param oEntity The entity data
             * @returns The found ETag (or null if none could be found)
            */
            getETag(sPath: string, oContext?: sap.ui.model.Context, oEntity?: any): string;

            /**
             * Returns all headers and custom headers which are stored in the OData model.
             * @returns the header map
            */
            getHeaders(): any;

            /**
             * Returns the key part from the entry URI or the given context or object
             * @param vValue A string representation of an URI, the context or entry object
             * @returns [sKey] key of the entry
            */
            getKey(vValue: string | any | sap.ui.model.Context): string;

            /**
             * Returns a metadata object for class sap.ui.model.odata.v2.ODataModel.
             * @returns Metadata object describing this class
            */
            getMetadata(): sap.ui.base.Metadata;

            /**
             * Returns an instance of an OData meta model which offers a unified access to both OData V2meta data
             * and V4 annotations. It uses the existing {@link sap.ui.model.odata.ODataMetadata}as a foundation and
             * merges V4 annotations from the existing{@link sap.ui.model.odata.v2.ODataAnnotations} directly into
             * the corresponding model element.<b>BEWARE:</b> Access to this OData meta model will fail before the
             * promise returned by{@link sap.ui.model.odata.ODataMetaModel#loaded loaded} has been resolved!
             * @returns The meta model for this ODataModel
            */
            getMetaModel(): sap.ui.model.odata.ODataMetaModel;

            /**
             * Returns the JSON object for an entity with the given <code>sPath</code> and optional
             * <code>oContext</code>.With the <code>mParameters.select</code> parameter it is possible to specify
             * comma separated property or navigation propertynames which should be included in the result object.
             * This works like the OData <code>$select</code> parameter.With the <code>mParameters.expand</code>
             * parameter it is possible to specify comma separated navigation property nameswhich should be
             * included inline in the result object. This works like the OData <code>$expand</code> parameter.This
             * method will return a copy and not a reference of the entity. It does not load any data and may not
             * return all requesteddata if it is not available/loaded. If select entries are contained in the
             * parameters and not all selected properties areavailable, this method will return undefined instead
             * of incomplete data. If no select entries are defined, all propertiesavailable on the client will be
             * returned.Example:<code>{select: "Products/ProductName, Products", expand:"Products"}</code> will
             * return no properties of the entity itself, butonly the ProductName property of the Products
             * navigation property. If Products/ProductName has not been loaded before, so is notavilable on the
             * client, it will return undefined.
             * @param sPath the path referencing the object
             * @param oContext the context the path should be resolved with, in case it is relative
             * @returns vValue the value for the given path/context or undefined if data or entity type could not
             * be found or was incomplete
            */
            getObject(sPath: string, oContext?: any): any;

            /**
             * Returns the original value for the property with the given path and context.The original value is
             * the value that was last responded by the server.
             * @param sPath the path/name of the property
             * @param oContext the context if available to access the property value
             * @returns vValue the value of the property
            */
            getOriginalProperty(sPath: string, oContext?: any): any;

            /**
             * Returns the value for the property with the given <code>sPath</code>.If the path points to a
             * navigation property which has been loaded via $expand then the
             * <code>bIncludeExpandEntries</code>parameter determines if the navigation property should be included
             * in the returned value or not.Please note that this currently works for 1..1 navigation properties
             * only.
             * @param sPath the path/name of the property
             * @param oContext the context if available to access the property value
             * @param bIncludeExpandEntries @deprecated Please use getObject function with select/expand parameters
             * instead.This parameter should be set when a URI or custom parameter with a $expand System Query
             * Option was used to retrieve associated entries embedded/inline.If true then the getProperty function
             * returns a desired property value/entry and includes the associated expand entries (if any).Note: A
             * copy and not a reference of the entry will be returned.
            */
            getProperty(sPath: string, oContext?: any, bIncludeExpandEntries?: boolean): any;

            /**
             * Returns the current security token. If the token has not been requested from the server it will be
             * requested first.
             * @returns the CSRF security token
            */
            getSecurityToken(): string;

            /**
             * Return the annotation object. Please note that the metadata is loaded asynchronously and this
             * function might return undefined because themetadata has not been loaded yet.In this case attach to
             * the <code>annotationsLoaded</code> event to get notified when the annotations are available and then
             * call this function.
             * @returns metdata object
            */
            getServiceAnnotations(): any;

            /**
             * Return the parsed XML metadata as a Javascript object. Please note that the metadata is loaded
             * asynchronously and this function might return undefined because themetadata has not been loaded
             * yet.In this case attach to the <code>metadataLoaded</code> event to get notified when the metadata
             * is available and then call this function.
             * @returns metdata object
            */
            getServiceMetadata(): any;

            /**
             * Checks if there exist pending changes in the model created by the setProperty method.
             * @returns true/false
            */
            hasPendingChanges(): boolean;

            /**
             * Checks if there are pending requests, either ongoing or sequential
             * @returns true/false
            */
            hasPendingRequests(): boolean;

            /**
             * Checks whether metadata loading has failed in the past.
             * @since 1.38
             * @returns returns whether metadata request has failed
            */
            isMetadataLoadingFailed(): boolean;

            /**
             * Returns a promise for the loaded state of the metadata. The promise won't get rejected in case the
             * metadata loading failed butis only resolved if the metadata is loaded successfully.If
             * <code>refreshMetadata</code> function is called after this promise is already resolved you should
             * rely on the promise returned by<code>refreshMetadata</code> to get information about the refreshed
             * metadata loaded state.
             * @since 1.30
             * @returns returns a promise on metadata loaded state
            */
            metadataLoaded(): JQueryPromise<any>;

            /**
             * Trigger a GET request to the odata service that was specified in the model constructor.The data will
             * be stored in the model. The requested data is returned with the response.
             * @param sPath A string containing the path to the data which should		be retrieved. The path is
             * concatenated to the sServiceUrl		which was specified in the model constructor.
             * @param mParameters Optional parameter map containing any of the following properties:
             * @returns an object which has an <code>abort</code> function to abort the current request.
            */
            read(sPath: string, mParameters?: any): any;

            /**
             * Refresh the model.This will check all bindings for updated data and update the controls if data has
             * been changed.
             * @param bForceUpdate Force update of controls
             * @param bRemoveData If set to true then the model data will be removed/cleared.					Please note that
             * the data might not be there when calling e.g. getProperty too early before the refresh call
             * returned.
             * @param sGroupId The groupId. Requests belonging to the same groupId will be bundled in one batch
             * request.
            */
            refresh(bForceUpdate: boolean, bRemoveData?: boolean, sGroupId?: string): void;

            /**
             * Refreshes the metadata for model, e.g. in case the request for metadata has failed.Returns a new
             * promise which can be resolved or rejected depending on the metadata loading state.
             * @returns returns a promise on metadata loaded state or null if metadata is not initialized or
             * currently refreshed.
            */
            refreshMetadata(): JQueryPromise<any>;

            /**
             * refresh XSRF token by performing a GET request against the service root URL.
             * @param fnSuccess a callback function which is called when the data has           					 been
             * successfully retrieved.
             * @param fnError a callback function which is called when the request failed. The handler can have the
             * parameter: oError which contains additional error information.
             * @returns an object which has an <code>abort</code> function to abort the current request.
            */
            refreshSecurityToken(fnSuccess: any, fnError?: any): any;

            /**
             * Trigger a DELETE request to the odata service that was specified in the model constructor.
             * @param sPath A string containing the path to the data that should be removed.		The path is
             * concatenated to the sServiceUrl which was specified in the model constructor.
             * @param mParameters Optional, can contain the following attributes:
             * @returns an object which has an <code>abort</code> function to abort the current request.
            */
            remove(sPath: string, mParameters?: any): any;

            /**
             * Resets the collected changes by the setProperty method.
             * @param aPath Array of paths that should be resetted.							If no array is passed all changes will be
             * resetted.
            */
            resetChanges(aPath: any[]): void;

            /**
             * Returns a promise, which will resolve with the security token as soon as it is available
             * @returns the CSRF security token
            */
            securityTokenAvailable(): JQueryPromise<any>;

            /**
             * Definition of batchGroups per EntityType for "TwoWay" changes
             * @param mGroups A map containing the definition of bacthGroups for TwoWay changes. The Map has
             * thefollowing format:{		"EntityTypeName": {			batchGroupId: "ID",			[changeSetId: "ID",]			[single:
             * true/false,]		}}bacthGroupId: Defines the bacthGroup for changes of the defined
             * EntityTypeNamechangeSetId: Defines a changeSetId wich bundles the changes for the EntityType.single:
             * Defines if every change will get an own changeSet (true)
            */
            setChangeBatchGroups(mGroups: any): void;

            /**
             * Definition of groups per EntityType for "TwoWay" changes
             * @param mGroups A map containing the definition of bacthGroups for TwoWay changes. The Map has
             * thefollowing format:{		"EntityTypeName": {			groupId: "ID",			[changeSetId: "ID",]			[single:
             * true/false,]		}}GroupId: Defines the Group for changes of the defined EntityTypeNamechangeSetId:
             * Defines a changeSetId wich bundles the changes for the EntityType.single: Defines if every change
             * will get an own changeSet (true)
            */
            setChangeGroups(mGroups: any): void;

            /**
             * Sets the default way to retrieve the count of collections in this model.Count can be determined
             * either by sending a separate $count request, including$inlinecount=allpages in data requests, both
             * of them or not at all.
             * @since 1.20
             * @param sCountMode sets default count mode
            */
            setDefaultCountMode(sCountMode: typeof sap.ui.model.odata.CountMode): void;

            /**
             * Setting batch groups as deferred. Requests that belongs to a deferred batch group will be sent
             * manuallyvia a submitChanges call.
             * @param aGroupIds Array of batchGroupIds that should be set as deferred
            */
            setDeferredBatchGroups(aGroupIds: any[]): void;

            /**
             * Setting request groups as deferred. Requests that belongs to a deferred group will be sent
             * manuallyvia a submitChanges call.
             * @param aGroupIds Array of GroupIds that should be set as deferred
            */
            setDeferredGroups(aGroupIds: any[]): void;

            /**
             * Set custom headers which are provided in a key/value map. These headers are used for requests
             * against the OData backend.Private headers which are set in the ODataModel cannot be modified.These
             * private headers are: accept, accept-language, x-csrf-token, MaxDataServiceVersion,
             * DataServiceVersion.To remove these headers simply set the mCustomHeaders parameter to null. Please
             * also note that when calling this method again all previous custom headersare removed unless they are
             * specified again in the mCustomHeaders parameter.
             * @param mHeaders the header name/value map.
            */
            setHeaders(mHeaders: any): void;

            /**
             * Sets a new value for the given property <code>sPropertyName</code> in the model.If the
             * changeBatchGroup for the changed EntityType is set to deferred changes could be submittedwith
             * submitChanges. Otherwise the change will be submitted directly.
             * @param sPath path of the property to set
             * @param oValue value to set the property to
             * @param oContext the context which will be used to set the property
             * @param bAsyncUpdate whether to update other bindings dependent on this property asynchronously
             * @returns true if the value was set correctly and false if errors occurred like the entry was not
             * found or another entry was already updated.
            */
            setProperty(sPath: string, oValue: any, oContext?: any, bAsyncUpdate?: boolean): boolean;

            /**
             * Enable/Disable automatic updates of all Bindings after change operations
             * @since 1.16.3
             * @param bRefreshAfterChange Refresh after change
            */
            setRefreshAfterChange(bRefreshAfterChange: boolean): void;

            /**
             * Enable/Disable XCSRF-Token handling
             * @param bTokenHandling whether to use token handling or not
            */
            setTokenHandlingEnabled(bTokenHandling: boolean): void;

            /**
             * @param bUseBatch whether the requests should be encapsulated in a batch request
            */
            setUseBatch(bUseBatch: boolean): void;

            /**
             * Submits the collected changes which were collected by the setProperty method. The update method is
             * defined by the global <code>defaultUpdateMethod</code>parameter which is
             * sap.ui.model.odata.UpdateMethod.Merge by default. In case of a sap.ui.model.odata.UpdateMethod.Merge
             * request only the changed properties will be updated.If a URI with a $expand System Query Option was
             * used then the expand entries will be removed from the collected changes.Changes to this entries
             * should be done on the entry itself. So no deep updates are supported.Important: The success/error
             * handler will only be called if batch support is enabled. If multiple batchGroups are submitted the
             * handlers will be called for every batchGroup.
             * @param mParameters a map which contains the following parameter properties:
             * @returns an object which has an <code>abort</code> function to abort the current request or requests
            */
            submitChanges(mParameters: any): any;

            /**
             * Trigger a PUT/MERGE request to the odata service that was specified in the model constructor.The
             * update method used is defined by the global <code>defaultUpdateMethod</code> parameter which is
             * sap.ui.model.odata.UpdateMethod.Merge by default.Please note that deep updates are not supported and
             * may not work. These should be done seperate on the entry directly.
             * @param sPath A string containing the path to the data that should be updated.		The path is
             * concatenated to the sServiceUrl which was specified		in the model constructor.
             * @param oData data of the entry that should be updated.
             * @param mParameters Optional, can contain the following attributes:
             * @returns an object which has an <code>abort</code> function to abort the current request.
            */
            update(sPath: string, oData: any, mParameters?: any): any;

            /**
             * update all bindings
             * @param bForceUpdate If set to false an update  will only be done when the value of a binding
             * changed.
            */
            updateBindings(bForceUpdate: boolean): void;
          }
          /**
           * Tree binding implementation for odata models.To use the v2.ODataTreeBinding with an odata service,
           * which exposes hierarchy annotations, pleaseconsult the "SAP Annotations for OData Version 2.0"
           * Specification.The necessary property annotations, as well as accepted/default values are documented
           * in the specification.In addition to these hieararchy annotations, the ODataTreeBinding also supports
           * (cyclic) references between entities based on navigation properties.To do this you have to specify
           * the binding parameter "navigation".The pattern for this is as follows: { entitySetName:
           * "navigationPropertyName" }.Example: {	 "Employees": "toColleagues"}In OperationMode.Server, the
           * filtering on the ODataTreeBinding is only supported with initial filters.However please be aware
           * that this applies only to filters which do not obstruct the creation of a hierarchy.So filtering on
           * a property (e.g. a "Customer") is fine, as long as the application can ensure, that the responses
           * from the backend are enoughto construct a tree hierarchy. Subsequent paging requests for sibiling
           * and child nodes must also return responses since the filters will be sent withevery
           * request.Filtering with the filter() function is not supported for the OperationMode.Server.With
           * OperationMode.Client and OperationMode.Auto, the ODataTreeBinding also supports control filters.In
           * these OperationModes, the filters and sorters will be applied clientside, same as for the
           * v2.ODataListBinding.The OperationModes "Client" and "Auto" are only supported for trees which will
           * be constructed based upon hierarchy annotations.
           * @resource sap/ui/model/odata/v2/ODataTreeBinding.js
          */
          export class ODataTreeBinding extends sap.ui.model.TreeBinding {


            constructor(oModel: sap.ui.model.Model, sPath: string, oContext: sap.ui.model.Context, aApplicationFilters?: sap.ui.model.Filter[], mParameters?: any, aSorters?: sap.ui.model.Sorter[]);




            /**
             * Applies the given filters to the ODataTreeBinding.Please note that "Control" filters are not
             * suported for OperationMode.Server, here only "Application" filters are allowed.Filters given via the
             * constructor are always Application filters and will be send with every backend-request.Please see
             * the constructor documentation for more information.Since 1.34.0 complete clientside filtering is
             * supported for OperationMode.Client and in OperationMode.Auto, in case the backend-count is lower
             * than the threshold.In this case all control and application filters will be applied on the
             * client.See also: {@link sap.ui.model.odata.OperationMode.Auto}, {@link sap.ui.model.FilterType}.For
             * the OperationMode.Client and OperationMode.Auto, you may also specify the
             * "useServersideApplicationFilters" constructor binding parameter.If this is set, the Application
             * filters will always be applied on the backend, and thus trigger an OData request.Please see the
             * constructor documentation for more information.
             * @param aFilters undefined
             * @param sFilterType Type of the filter which should be adjusted, if it is not given, the standard
             * behaviour FilterType.Client applies
             * @returns returns <code>this</code> to facilitate method chaining
            */
            filter(aFilters: sap.ui.model.Filter[] | sap.ui.model.Filter, sFilterType: typeof sap.ui.model.FilterType): sap.ui.model.odata.v2.ODataTreeBinding;

            /**
             * Returns the number of child nodes. This function is not available when the annotation
             * "hierarchy-node-descendant-count-for"is exposed on the service.
             * @param oContext the context element of the node
             * @returns the number of children
            */
            getChildCount(oContext: any): number;

            /**
             * Get a download URL with the specified format considering thesort/filter/custom parameters.
             * @since 1.28
             * @param sFormat Value for the $format Parameter
             * @returns URL which can be used for downloading
            */
            getDownloadUrl(sFormat: string): string;

            /**
             * Returns a metadata object for class sap.ui.model.odata.v2.ODataTreeBinding.
             * @returns Metadata object describing this class
            */
            getMetadata(): sap.ui.base.Metadata;

            /**
             * Returns the contexts of the child nodes for the given context. This function is not available when
             * the annotation "hierarchy-node-descendant-count-for"is exposed on the service.
             * @param oContext the context for which the child nodes should be retrieved
             * @param iStartIndex the start index of the requested contexts
             * @param iLength the requested amount of contexts
             * @param iThreshold undefined
             * @returns the contexts array
            */
            getNodeContexts(oContext: any, iStartIndex: number, iLength: number, iThreshold?: number): any[];

            /**
             * Returns root contexts for the tree. You can specify the start index and the length for paging
             * requests.This function is not available when the annotation "hierarchy-node-descendant-count-for" is
             * exposed on the service.
             * @param iStartIndex the start index of the requested contexts
             * @param iLength the requested amount of contexts. If none given, the default value is the size limit
             * of the underlying												 sap.ui.model.odata.v2.ODataModel instance.
             * @param iThreshold the number of entities which should be retrieved in addition to the given length.	
             * 		  A higher threshold reduces the number of backend requests, yet these request blow up in size,
             * since more data is loaded.
             * @returns an array containing the contexts for the entities returned by the backend, might be fewer
             * than requested								  if the backend does not have enough data.
            */
            getRootContexts(iStartIndex: number, iLength?: number, iThreshold?: number): sap.ui.model.Context[];

            /**
             * Returns the rootLevel
            */
            getRootLevel(): number;

            /**
             * Returns if the node has child nodes.If the ODataTreeBinding is running with hierarchy annotations, a
             * context with the property values "expanded" or "collapsed"for the drilldown state property, returns
             * true. Entities with drilldown state "leaf" return false.This function is not available when the
             * annotation "hierarchy-node-descendant-count-for" is exposed on the service.
             * @param oContext the context element of the node
             * @returns true if node has children
            */
            hasChildren(oContext: sap.ui.model.Context): boolean;

            /**
             * Initialize binding. Fires a change if data is already available ($expand) or a refresh.If metadata
             * is not yet available, do nothing, method will be called again whenmetadata is loaded.
             * @returns The binding instance
            */
            initialize(): sap.ui.model.odata.v2.ODataTreeBinding;

            /**
             * Refreshes the binding, check whether the model data has been changed and fire change eventif this is
             * the case. For server side models this should refetch the data from the server.To update a control,
             * even if no data has been changed, e.g. to reset a control after failedvalidation, please use the
             * parameter bForceUpdate.
             * @param bForceUpdate Update the bound control even if no data has been changed
             * @param sGroupId The  group Id for the refresh
            */
            refresh(bForceUpdate: boolean, sGroupId?: string): void;

            /**
             * Sets the rootLevelThe root level is the level of the topmost tree nodes, which will be used as an
             * entry point for OData services.This is only possible (and necessary) for OData services implementing
             * the hierarchy annotation specification,or when providing the annotation information locally as a
             * binding parameter. See the constructor for API documentation on this.
             * @param iRootLevel undefined
            */
            setRootLevel(iRootLevel: number): void;

            /**
             * Sorts the Tree according to the given Sorter(s).In OperationMode.Client or OperationMode.Auto (if
             * the given threshold is satisfied), the sorters are applied locally on the client.
             * @param aSorters the Sorter or an Array of sap.ui.model.Sorter instances
             * @returns returns <code>this</code> to facilitate method chaining
            */
            sort(aSorters: sap.ui.model.Sorter[] | sap.ui.model.Sorter): sap.ui.model.ListBinding | void;
          }
          /**
           * Annotation loader for OData V2 services
           * @resource sap/ui/model/odata/v2/ODataAnnotations.js
          */
          export class ODataAnnotations extends sap.ui.base.EventProvider {


            constructor();



            /**
             * This event exists for compatibility with the old Annotation loaderAttaches the given callback to the
             * <code>allFailed</code> event. This event is fired when no annotation from a group ofsources was
             * successfully (loaded,) parsed and merged.The parameter <code>result</code> will be set on the event
             * argument and contains an array of Errors in the order in whichthe sources had been added.
             * @param oData The object, that should be passed along with the event-object when firing the event.
             * @param fnFunction The event callback. This function will be called in the context of the oListener  
             *     object if given as the next argument.
             * @param oListener Object to use as context of the callback. If empty, the global context is used.
             * @returns <code>this</code>-reference to allow method chaining
            */
            attachAllFailed(oData: any, fnFunction: any, oListener?: any): sap.ui.model.odata.v2.ODataAnnotations;

            /**
             * Attaches the given callback to the <code>error</code> event, which is fired whenever a source cannot
             * be loaded, parsed ormerged into the annotation data.The following parameters will be set on the
             * event object that is given to the callback function:  <code>source</code> - A map containing the
             * properties <code>type</code> - containing either "url" or "xml" - and <code>data</code> containing  
             *           the data given as source, either an URL or an XML string depending on how the source was
             * added.  <code>error</code>  - An Error object describing the problem that occurred
             * @param oData The object, that should be passed along with the event-object when firing the event.
             * @param fnFunction The event callback. This function will be called in the context of the oListener  
             *     object if given as the next argument.
             * @param oListener Object to use as context of the callback. If empty, the global context is used.
             * @returns <code>this</code>-reference to allow method chaining
            */
            attachError(oData: any, fnFunction: any, oListener?: any): sap.ui.model.odata.v2.ODataAnnotations;

            /**
             * Attaches the given callback to the <code>failed</code> event. This event is fired when at least one
             * annotation from a groupof sources was not successfully (loaded,) parsed or merged.The parameter
             * <code>result</code> will be set on the event argument and contains an array of Errors in the order
             * in whichthe sources had been added.
             * @param oData The object, that should be passed along with the event-object when firing the event.
             * @param fnFunction The event callback. This function will be called in the context of the oListener  
             *     object if given as the next argument.
             * @param oListener Object to use as context of the callback. If empty, the global context is used.
             * @returns <code>this</code>-reference to allow method chaining
            */
            attachFailed(oData: any, fnFunction: any, oListener?: any): sap.ui.model.odata.v2.ODataAnnotations;

            /**
             * Attaches the given callback to the <code>loaded</code> event. This event is fired when all
             * annotations from a group ofsources was successfully (loaded,) parsed and merged.The parameter
             * <code>result</code> will be set on the event argument and contains an array of all loaded sources as
             * wellas Errors in the order in which they had been added.
             * @param oData The object, that should be passed along with the event-object when firing the event.
             * @param fnFunction The event callback. This function will be called in the context of the oListener  
             *     object if given as the next argument.
             * @param oListener Object to use as context of the callback. If empty, the global context is used.
             * @returns <code>this</code>-reference to allow method chaining
            */
            attachLoaded(oData: any, fnFunction: any, oListener?: any): sap.ui.model.odata.v2.ODataAnnotations;

            /**
             * This event exists for compatibility with the old Annotation loaderAttaches the given callback to the
             * <code>someLoaded</code> event. This event is fired when at least one annotation from agroup of
             * sources was successfully (loaded,) parsed and merged.The parameter <code>result</code> will be set
             * on the event argument and contains an array of all loaded sources as wellas Errors in the order in
             * which they had been added.
             * @param oData The object, that should be passed along with the event-object when firing the event.
             * @param fnFunction The event callback. This function will be called in the context of the oListener  
             *     object if given as the next argument.
             * @param oListener Object to use as context of the callback. If empty, the global context is used.
             * @returns <code>this</code>-reference to allow method chaining
            */
            attachSomeLoaded(oData: any, fnFunction: any, oListener?: any): sap.ui.model.odata.v2.ODataAnnotations;

            /**
             * Attaches the given callback to the <code>success</code> event, which is fired whenever a source has
             * been successfully(loaded,) parsed and merged into the annotation data.The following parameters will
             * be set on the event object that is given to the callback function:  <code>source</code> - A map
             * containing the properties <code>type</code> - containing either "url" or "xml" - and
             * <code>data</code> containing             the data given as source, either an URL or an XML string
             * depending on how the source was added.
             * @param oData The object, that should be passed along with the event-object when firing the event.
             * @param fnFunction The event callback. This function will be called in the context of the oListener  
             *     object if given as the next argument.
             * @param oListener Object to use as context of the callback. If empty, the global context is used.
             * @returns <code>this</code>-reference to allow method chaining.
            */
            attachSuccess(oData: any, fnFunction: any, oListener?: any): sap.ui.model.odata.v2.ODataAnnotations;

            /**
             * Detaches the given callback from the <code>allFailed</code> event.The passed function and listener
             * object must match the ones previously used for attaching to the event.
             * @param fnFunction The event callback previously used with {@link
             * sap.ui.model.odata.v2.ODataAnnotations#attachFailed}.
             * @param oListener The same (if any) context object that was used when attaching to the
             * <code>error</code> event.
             * @returns <code>this</code>-reference to allow method chaining.
            */
            detachAllFailed(fnFunction: any, oListener?: any): sap.ui.model.odata.v2.ODataAnnotations;

            /**
             * Detaches the given callback from the <code>error</code> event.The passed function and listener
             * object must match the ones previously used for attaching to the event.
             * @param fnFunction The event callback previously used with {@link
             * sap.ui.model.odata.v2.ODataAnnotations#attachError}.
             * @param oListener The same (if any) context object that was used when attaching to the
             * <code>error</code> event.
             * @returns <code>this</code>-reference to allow method chaining.
            */
            detachError(fnFunction: any, oListener?: any): sap.ui.model.odata.v2.ODataAnnotations;

            /**
             * Detaches the given callback from the <code>failed</code> event.The passed function and listener
             * object must match the ones previously used for attaching to the event.
             * @param fnFunction The event callback previously used with {@link
             * sap.ui.model.odata.v2.ODataAnnotations#attachFailed}.
             * @param oListener The same (if any) context object that was used when attaching to the
             * <code>error</code> event.
             * @returns <code>this</code>-reference to allow method chaining.
            */
            detachFailed(fnFunction: any, oListener?: any): sap.ui.model.odata.v2.ODataAnnotations;

            /**
             * Detaches the given callback from the <code>loaded</code> event.The passed function and listener
             * object must match the ones previously used for attaching to the event.
             * @param fnFunction The event callback previously used with {@link
             * sap.ui.model.odata.v2.ODataAnnotations#attachLoaded}.
             * @param oListener The same (if any) context object that was used when attaching to the
             * <code>error</code> event.
             * @returns <code>this</code>-reference to allow method chaining.
            */
            detachLoaded(fnFunction: any, oListener?: any): sap.ui.model.odata.v2.ODataAnnotations;

            /**
             * Detaches the given callback from the <code>someLoaded</code> event.The passed function and listener
             * object must match the ones previously used for attaching to the event.
             * @param fnFunction The event callback previously used with {@link
             * sap.ui.model.odata.v2.ODataAnnotations#attachSomeLoaded}.
             * @param oListener The same (if any) context object that was used when attaching to the
             * <code>error</code> event.
             * @returns <code>this</code>-reference to allow method chaining.
            */
            detachSomeLoaded(fnFunction: any, oListener?: any): sap.ui.model.odata.v2.ODataAnnotations;

            /**
             * Detaches the given callback from the <code>success</code> event.The passed function and listener
             * object must match the ones previously used for attaching to the event.
             * @param fnFunction The event callback previously used with {@link
             * sap.ui.model.odata.v2.ODataAnnotations#attachSuccess}.
             * @param oListener The same (if any) context object that was used when attaching to the
             * <code>success</code> event.
             * @returns <code>this</code>-reference to allow method chaining.
            */
            detachSuccess(fnFunction: any, oListener?: any): sap.ui.model.odata.v2.ODataAnnotations;


            /**
             * V1 API Compatibility method. @see sap.ui.model.odata.v2.ODataAnnotations#getDataReturns the parsed
             * and merged annotation data object
             * @returns returns annotations data
            */
            getAnnotationsData(): any;

            /**
             * Returns the parsed and merged annotation data object
             * @returns returns annotations data
            */
            getData(): any;

            /**
             * Returns a metadata object for class sap.ui.model.odata.v2.ODataAnnotations.
             * @returns Metadata object describing this class
            */
            getMetadata(): sap.ui.base.Metadata;

            /**
             * Returns a promise that resolves when the annotation sources that were added up to this point were
             * successfully(loaded,) parsed and merged
             * @returns The Promise that resolves/rejects after the last added sources have been processed
            */
            loaded(): JQueryPromise<any>;

            /**
             * Set custom headers which are provided in a key/value map. These headers are used for all
             * requests.The "Accept-Language" header cannot be modified and is set using the core's language
             * setting.To remove these headers, simply set the <code>mHeaders</code> parameter to <code>{}</code>.
             * Please also note that when calling this methodagain all previous custom headers are removed unless
             * they are specified again in the <code>mCustomHeaders</code> parameter.
             * @param mHeaders the header name/value map.
            */
            setHeaders(mHeaders: any): void;
          }
          /**
           * List binding implementation for oData format
           * @resource sap/ui/model/odata/v2/ODataListBinding.js
          */
          export class ODataListBinding extends sap.ui.model.ListBinding {


            constructor(oModel: sap.ui.model.Model, sPath: string, oContext: sap.ui.model.Context, aSorters?: any[], aFilters?: any[], mParameters?: any);




            /**
             * Filters the list.When using sap.ui.model.Filter the filters are first grouped according to their
             * binding path.All filters belonging to a group are combined with OR and after that theresults of all
             * groups are combined with AND.Usually this means, all filters applied to a single table columnare
             * combined with OR, while filters on different table columns are combined with AND.Please note that a
             * custom filter function is only supported with operation mode
             * <code>sap.ui.model.odata.OperationMode.Client</code>.
             * @param aFilters Array of filter objects
             * @param sFilterType Type of the filter which should be adjusted, if it is not given, the standard
             * behaviour applies
             * @returns returns <code>this</code> to facilitate method chaining
            */
            filter(aFilters: sap.ui.model.Filter[] | sap.ui.model.odata.Filter[], sFilterType: typeof sap.ui.model.FilterType): sap.ui.model.ListBinding;

            /**
             * Return contexts for the list
             * @param iStartIndex the start index of the requested contexts
             * @param iLength the requested amount of contexts
             * @param iThreshold The threshold value
             * @returns the array of contexts for each row of the bound list
            */
            getContexts(iStartIndex: number, iLength?: number, iThreshold?: number): sap.ui.model.Context[];

            /**
             * Get a download URL with the specified format considering thesort/filter/custom parameters.
             * @since 1.24
             * @param sFormat Value for the $format Parameter
             * @returns URL which can be used for downloading
            */
            getDownloadUrl(sFormat: string): string;

            /**
             * Return the length of the list.In case the final length is unknown (e.g. when searching on a large
             * dataset), this willreturn an estimated length.
             * @returns the length
            */
            getLength(): number;

            /**
             * Returns a metadata object for class sap.ui.model.odata.v2.ODataListBinding.
             * @returns Metadata object describing this class
            */
            getMetadata(): sap.ui.base.Metadata;

            /**
             * Initialize binding. Fires a change if data is already available ($expand) or a refresh.If metadata
             * is not yet available, do nothing, method will be called again whenmetadata is loaded.
             * @returns oBinding The binding instance
            */
            initialize(): sap.ui.model.odata.ODataListBinding;

            /**
             * Refreshes the binding, check whether the model data has been changed and fire change eventif this is
             * the case. For server side models this should refetch the data from the server.To update a control,
             * even if no data has been changed, e.g. to reset a control after failedvalidation, please use the
             * parameter bForceUpdate.
             * @param bForceUpdate Update the bound control even if no data has been changed
             * @param sGroupId The group Id for the refresh
            */
            refresh(bForceUpdate: boolean, sGroupId?: string): void;

            /**
             * Sorts the list.
             * @param aSorters the Sorter or an array of sorter objects object which define the sort order
             * @returns returns <code>this</code> to facilitate method chaining
            */
            sort(aSorters: sap.ui.model.Sorter[] | sap.ui.model.Sorter): sap.ui.model.ListBinding | void;
          }
          /**
           * The ContextBinding is a specific binding for a setting context for the model
           * @resource sap/ui/model/odata/v2/ODataContextBinding.js
          */
          export abstract class ODataContextBinding extends sap.ui.model.ContextBinding {


            /**
             * Constructor for odata.ODataContextBinding
             * @param oModel undefined
             * @param sPath undefined
             * @param oContext undefined
             * @param mParameters a map which contains additional parameters for the binding.
            */
            constructor(oModel: sap.ui.model.Model, sPath: String, oContext: any, mParameters?: any);




            /**
             * Returns a metadata object for class sap.ui.model.odata.v2.ODataContextBinding.
             * @returns Metadata object describing this class
            */
            getMetadata(): sap.ui.base.Metadata;

            /**
             * @param bForceUpdate Update the bound control even if no data has been changed
             * @param sGroupId The group Id for the refresh
            */
            refresh(bForceUpdate: boolean, sGroupId?: string): void;
          }
        }
        namespace type {
          /**
           * This class represents a placeholder for all unsupported OData primitive types. It can  only be used
           * to retrieve raw values "as is" (i.e. <code>formatValue(vValue, "any")</code>),  but not to actually
           * convert to or from any other representation or to validate.
           * @resource sap/ui/model/odata/type/Raw.js
          */
          export class Raw extends sap.ui.model.odata.type.ODataType {


            /**
             * Constructor for a placeholder for all unsupported OData primitive types.
             * @param oFormatOptions Must be <code>undefined</code>
             * @param oConstraints Must be <code>undefined</code>
            */
            constructor(oFormatOptions: any, oConstraints?: any);




            /**
             * Formats the given value to the given target type.
             * @since 1.37.0
             * @param vValue The raw value to be retrieved "as is"
             * @param sTargetType The target type; must be "any"
             * @returns The raw value "as is"
            */
            formatValue(vValue: any, sTargetType: string): any;

            /**
             * Returns a metadata object for class sap.ui.model.odata.type.Raw.
             * @returns Metadata object describing this class
            */
            getMetadata(): sap.ui.base.Metadata;

            /**
             * Returns the type's name.
             * @since 1.37.0
             * @returns The type's name
            */
            getName(): string;

            /**
             * Method not supported
             * @since 1.37.0
            */
            parseValue(): void;

            /**
             * Method not supported
             * @since 1.37.0
            */
            validateValue(): void;
          }
          /**
           * This is an abstract base class for integer-based<a
           * href="http://www.odata.org/documentation/odata-version-2-0/overview#AbstractTypeSystem">OData
           * primitive types</a> like <code>Edm.Int16</code> or <code>Edm.Int32</code>.
           * @resource sap/ui/model/odata/type/Int.js
          */
          export class Int extends sap.ui.model.odata.type.ODataType {


            /**
             * Constructor for a new <code>Int</code>.
             * @param oFormatOptions type-specific format options; see subtypes
             * @param oConstraints constraints; {@link #validateValue validateValue} throws an error if any
             * constraint is  violated
            */
            constructor(oFormatOptions: any, oConstraints?: any);




            /**
             * Formats the given value to the given target type.When formatting to <code>string</code> the format
             * options are used.
             * @param iValue the value in model representation to be formatted
             * @param sTargetType the target type; may be "any", "int", "float" or "string".  See {@link
             * sap.ui.model.odata.type} for more information.
             * @returns the formatted output value in the target type; <code>undefined</code> or <code>null</code> 
             * are formatted to <code>null</code>
            */
            formatValue(iValue: number, sTargetType: string): number | string;

            /**
             * Returns a metadata object for class sap.ui.model.odata.type.Int.
             * @returns Metadata object describing this class
            */
            getMetadata(): sap.ui.base.Metadata;

            /**
             * Parses the given value, which is expected to be of the given source type, to an Int innumber
             * representation.
             * @param vValue the value to be parsed. The empty string and <code>null</code> are parsed to 
             * <code>null</code>.
             * @param sSourceType the source type (the expected type of <code>vValue</code>); may be "float", "int"
             * or  "string".  See {@link sap.ui.model.odata.type} for more information.
             * @returns the parsed value
            */
            parseValue(vValue: number | string, sSourceType: string): number;

            /**
             * Validates whether the given value in model representation is valid and meets thedefined constraints.
             * @param iValue the value to be validated
            */
            validateValue(iValue: number): void;
          }
          /**
           * This class represents the OData primitive type
           * .odata.org/documentation/odata-version-2-0/overview#AbstractTypeSystem"><code>Edm.Byte</code></a>.In
           * both {@link sap.ui.model.odata.v2.ODataModel} and {@link sap.ui.model.odata.v4.ODataModel}this type
           * is represented as a <code>number</code>.
           * @resource sap/ui/model/odata/type/Byte.js
          */
          export class Byte extends sap.ui.model.odata.type.Int {


            /**
             * Constructor for a primitive type <code>Edm.Byte</code>.
             * @param oFormatOptions format options as defined in {@link sap.ui.core.format.NumberFormat}
             * @param oConstraints constraints; {@link sap.ui.model.odata.type.Int#validateValue validateValue}
             * throws an  error if any constraint is violated
            */
            constructor(oFormatOptions: any, oConstraints?: any);




            /**
             * Returns a metadata object for class sap.ui.model.odata.type.Byte.
             * @returns Metadata object describing this class
            */
            getMetadata(): sap.ui.base.Metadata;

            /**
             * Returns the type's name.
             * @returns the type's name
            */
            getName(): string;

            /**
             * Returns the type's supported range as object with properties <code>minimum</code>
             * and<code>maximum</code>.
             * @returns the range
            */
            getRange(): any;
          }
          /**
           * This class represents the OData V4 primitive type <code>Edm.Date</code>.In {@link
           * sap.ui.model.odata.v4.ODataModel} this type is represented as a<code>string</code> in the format
           * "yyyy-mm-dd".
           * @resource sap/ui/model/odata/type/Date.js
          */
          export class Date extends sap.ui.model.odata.type.ODataType {


            /**
             * Constructor for an OData primitive type <code>Edm.Date</code>.
             * @param oFormatOptions format options as defined in {@link sap.ui.core.format.DateFormat}
             * @param oConstraints constraints; {@link #validateValue validateValue} throws an error if any
             * constraint is  violated
            */
            constructor(oFormatOptions: any, oConstraints?: any);




            /**
             * Formats the given value to the given target type.
             * @param sValue the value to be formatted
             * @param sTargetType the target type; may be "any" or "string".  See {@link sap.ui.model.odata.type}
             * for more information.
             * @returns the formatted output value in the target type; <code>undefined</code> or <code>null</code> 
             * are formatted to <code>null</code>
            */
            formatValue(sValue: string, sTargetType: string): string;

            /**
             * Returns a metadata object for class sap.ui.model.odata.type.Date.
             * @returns Metadata object describing this class
            */
            getMetadata(): sap.ui.base.Metadata;

            /**
             * Returns the type's name.
             * @returns the type's name
            */
            getName(): string;

            /**
             * Parses the given value to a date.
             * @param sValue the value to be parsed, maps <code>""</code> to <code>null</code>
             * @param sSourceType the source type (the expected type of <code>sValue</code>); must be "string"  See
             * {@link sap.ui.model.odata.type} for more information.
             * @returns the parsed value
            */
            parseValue(sValue: string, sSourceType: string): string;

            /**
             * Validates whether the given value in model representation is valid and meets thegiven constraints.
             * @param sValue the value to be validated
            */
            validateValue(sValue: string): void;
          }
          /**
           * This class represents the OData V2 primitive type
           * .odata.org/documentation/odata-version-2-0/overview#AbstractTypeSystem"><code>Edm.Time</code></a>.In
           * {@link sap.ui.model.odata.v2.ODataModel ODataModel} this type is represented as anobject with two
           * properties:<ul><li><code>__edmType</code> with the value "Edm.Time"<li><code>ms</code> with the
           * number of milliseconds since midnight</ul>
           * @resource sap/ui/model/odata/type/Time.js
          */
          export class Time extends sap.ui.model.odata.type.ODataType {


            /**
             * Constructor for an OData primitive type <code>Edm.Time</code>.
             * @param oFormatOptions format options as defined in {@link sap.ui.core.format.DateFormat}
             * @param oConstraints constraints; {@link #validateValue validateValue} throws an error if any
             * constraint is  violated
            */
            constructor(oFormatOptions: any, oConstraints?: any);




            /**
             * Formats the given value to the given target type
             * @param oValue the value in model representation to be formatted.
             * @param sTargetType the target type; may be "any" or "string".  See {@link sap.ui.model.odata.type}
             * for more information.
             * @returns the formatted output value in the target type; <code>undefined</code> or <code>null</code> 
             * are formatted to <code>null</code>
            */
            formatValue(oValue: any, sTargetType: string): string;

            /**
             * Returns a metadata object for class sap.ui.model.odata.type.Time.
             * @returns Metadata object describing this class
            */
            getMetadata(): sap.ui.base.Metadata;

            /**
             * Returns the type's name.
             * @returns the type's name
            */
            getName(): string;

            /**
             * Parses the given value, which is expected to be of the given type, to a time object.
             * @param sValue the value to be parsed, maps <code>""</code> to <code>null</code>
             * @param sSourceType the source type (the expected type of <code>sValue</code>); must be "string". 
             * See {@link sap.ui.model.odata.type} for more information.
             * @returns the parsed value as described in {@link #formatValue formatValue}
            */
            parseValue(sValue: string, sSourceType: string): any;

            /**
             * Validates whether the given value in model representation is valid and meets thedefined constraints.
             * @param oValue the value to be validated
            */
            validateValue(oValue: any): void;
          }
          /**
           * This class represents the OData primitive type
           * .odata.org/documentation/odata-version-2-0/overview#AbstractTypeSystem"><code>Edm.Guid</code></a>.In
           * both {@link sap.ui.model.odata.v2.ODataModel} and {@link sap.ui.model.odata.v4.ODataModel}this type
           * is represented as a <code>string</code>.
           * @resource sap/ui/model/odata/type/Guid.js
          */
          export class Guid extends sap.ui.model.odata.type.ODataType {


            /**
             * Constructor for an OData primitive type <code>Edm.Guid</code>.
             * @param oFormatOptions format options as defined in the interface of {@link sap.ui.model.SimpleType};
             * this  type ignores them since it does not support any format options
             * @param oConstraints constraints; {@link #validateValue validateValue} throws an error if any
             * constraint is  violated
            */
            constructor(oFormatOptions: any, oConstraints?: any);




            /**
             * Formats the given value to the given target type.
             * @param sValue the value to be formatted
             * @param sTargetType the target type; may be "any" or "string".  See {@link sap.ui.model.odata.type}
             * for more information.
             * @returns the formatted output value in the target type; <code>undefined</code> or <code>null</code> 
             * are formatted to <code>null</code>
            */
            formatValue(sValue: string, sTargetType: string): string;

            /**
             * Returns a metadata object for class sap.ui.model.odata.type.Guid.
             * @returns Metadata object describing this class
            */
            getMetadata(): sap.ui.base.Metadata;

            /**
             * Returns the type's name.
             * @returns the type's name
            */
            getName(): string;

            /**
             * Parses the given value to a GUID.
             * @param sValue the value to be parsed, maps <code>""</code> to <code>null</code>
             * @param sSourceType the source type (the expected type of <code>sValue</code>); must be "string". 
             * See {@link sap.ui.model.odata.type} for more information.
             * @returns the parsed value
            */
            parseValue(sValue: string, sSourceType: string): string;

            /**
             * Validates whether the given value in model representation is valid and meets thegiven constraints.
             * @param sValue the value to be validated
            */
            validateValue(sValue: string): void;
          }
          /**
           * This class represents the OData primitive type
           * odata.org/documentation/odata-version-2-0/overview#AbstractTypeSystem"><code>Edm.SByte</code></a>.In
           * both {@link sap.ui.model.odata.v2.ODataModel} and {@link sap.ui.model.odata.v4.ODataModel}this type
           * is represented as a <code>number</code>.
           * @resource sap/ui/model/odata/type/SByte.js
          */
          export class SByte extends sap.ui.model.odata.type.Int {


            /**
             * Constructor for a primitive type <code>Edm.SByte</code>.
             * @param oFormatOptions format options as defined in {@link sap.ui.core.format.NumberFormat}
             * @param oConstraints constraints; {@link sap.ui.model.odata.type.Int#validateValue validateValue}
             * throws an  error if any constraint is violated
            */
            constructor(oFormatOptions: any, oConstraints?: any);




            /**
             * Returns a metadata object for class sap.ui.model.odata.type.SByte.
             * @returns Metadata object describing this class
            */
            getMetadata(): sap.ui.base.Metadata;

            /**
             * Returns the type's name.
             * @returns the type's name
            */
            getName(): string;

            /**
             * Returns the type's supported range as object with properties <code>minimum</code>
             * and<code>maximum</code>.
             * @returns the range
            */
            getRange(): any;
          }
          /**
           * This class represents the OData primitive type
           * odata.org/documentation/odata-version-2-0/overview#AbstractTypeSystem"><code>Edm.Int64</code></a>.In
           * both {@link sap.ui.model.odata.v2.ODataModel} and {@link sap.ui.model.odata.v4.ODataModel}this type
           * is represented as a <code>string</code>.
           * @resource sap/ui/model/odata/type/Int64.js
          */
          export class Int64 extends sap.ui.model.odata.type.ODataType {


            /**
             * Constructor for a primitive type <code>Edm.Int64</code>.
             * @param oFormatOptions format options as defined in {@link sap.ui.core.format.NumberFormat}. In
             * contrast to  NumberFormat <code>groupingEnabled</code> defaults to <code>true</code>.
             * @param oConstraints constraints; {@link #validateValue validateValue} throws an error if any
             * constraint is  violated
            */
            constructor(oFormatOptions: any, oConstraints: any);




            /**
             * Formats the given value to the given target type.
             * @param sValue the value to be formatted, which is represented as a string in the model
             * @param sTargetType the target type; may be "any", "float", "int" or "string".  See {@link
             * sap.ui.model.odata.type} for more information.
             * @returns the formatted output value in the target type; <code>undefined</code> or <code>null</code> 
             * are formatted to <code>null</code>
            */
            formatValue(sValue: string, sTargetType: string): number | string;

            /**
             * Returns a metadata object for class sap.ui.model.odata.type.Int64.
             * @returns Metadata object describing this class
            */
            getMetadata(): sap.ui.base.Metadata;

            /**
             * Returns the type's name.
             * @returns the type's name
            */
            getName(): string;

            /**
             * Parses the given value, which is expected to be of the given type, to an Int64 in<code>string</code>
             * representation.
             * @param vValue the value to be parsed; the empty string and <code>null</code> are parsed to 
             * <code>null</code>
             * @param sSourceType the source type (the expected type of <code>vValue</code>); may be "float", "int"
             * or  "string".  See {@link sap.ui.model.odata.type} for more information.
             * @returns the parsed value
            */
            parseValue(vValue: string | number, sSourceType: string): string;

            /**
             * Validates whether the given value in model representation is valid and meets thedefined constraints.
             * @param sValue the value to be validated
            */
            validateValue(sValue: string): void;
          }
          /**
           * This class represents the OData primitive type
           * odata.org/documentation/odata-version-2-0/overview#AbstractTypeSystem"><code>Edm.Int32</code></a>.In
           * both {@link sap.ui.model.odata.v2.ODataModel} and {@link sap.ui.model.odata.v4.ODataModel}this type
           * is represented as a <code>number</code>.
           * @resource sap/ui/model/odata/type/Int32.js
          */
          export class Int32 extends sap.ui.model.odata.type.Int {


            /**
             * Constructor for a primitive type <code>Edm.Int32</code>.
             * @param oFormatOptions format options as defined in {@link sap.ui.core.format.NumberFormat}. In
             * contrast to  NumberFormat <code>groupingEnabled</code> defaults to <code>true</code>.
             * @param oConstraints constraints; {@link sap.ui.model.odata.type.Int#validateValue validateValue}
             * throws an  error if any constraint is violated
            */
            constructor(oFormatOptions: any, oConstraints?: any);




            /**
             * Returns a metadata object for class sap.ui.model.odata.type.Int32.
             * @returns Metadata object describing this class
            */
            getMetadata(): sap.ui.base.Metadata;

            /**
             * Returns the type's name.
             * @returns the type's name
            */
            getName(): string;

            /**
             * Returns the type's supported range as object with properties <code>minimum</code>
             * and<code>maximum</code>.
             * @returns the range
            */
            getRange(): any;
          }
          /**
           * This class represents the OData primitive type
           * odata.org/documentation/odata-version-2-0/overview#AbstractTypeSystem"><code>Edm.Int16</code></a>.In
           * both {@link sap.ui.model.odata.v2.ODataModel} and {@link sap.ui.model.odata.v4.ODataModel}this type
           * is represented as a <code>number</code>.
           * @resource sap/ui/model/odata/type/Int16.js
          */
          export class Int16 extends sap.ui.model.odata.type.Int {


            /**
             * Constructor for a primitive type <code>Edm.Int16</code>.
             * @param oFormatOptions format options as defined in {@link sap.ui.core.format.NumberFormat}. In
             * contrast to  NumberFormat <code>groupingEnabled</code> defaults to <code>true</code>.
             * @param oConstraints constraints; {@link sap.ui.model.odata.type.Int#validateValue validateValue}
             * throws an  error if any constraint is violated
            */
            constructor(oFormatOptions: any, oConstraints?: any);




            /**
             * Returns a metadata object for class sap.ui.model.odata.type.Int16.
             * @returns Metadata object describing this class
            */
            getMetadata(): sap.ui.base.Metadata;

            /**
             * Returns the type's name.
             * @returns the type's name
            */
            getName(): string;

            /**
             * Returns the type's supported range as object with properties <code>minimum</code>
             * and<code>maximum</code>.
             * @returns the range
            */
            getRange(): any;
          }
          /**
           * This class represents the OData primitive type
           * data.org/documentation/odata-version-2-0/overview#AbstractTypeSystem"><code>Edm.Double</code></a>.In
           * both {@link sap.ui.model.odata.v2.ODataModel} and {@link sap.ui.model.odata.v4.ODataModel}this type
           * is represented as a <code>number</code>.
           * @resource sap/ui/model/odata/type/Double.js
          */
          export class Double extends sap.ui.model.odata.type.ODataType {


            /**
             * Constructor for a primitive type <code>Edm.Double</code>.
             * @param oFormatOptions format options as defined in {@link sap.ui.core.format.NumberFormat}. In
             * contrast to  NumberFormat <code>groupingEnabled</code> defaults to <code>true</code>.
             * @param oConstraints constraints; {@link #validateValue validateValue} throws an error if any
             * constraint is  violated
            */
            constructor(oFormatOptions: any, oConstraints?: any);




            /**
             * Formats the given value to the given target type. When formatting to "string", very largeor very
             * small values are formatted to the exponential format (e.g. "-3.14 E+15").
             * @param vValue the value to be formatted, which is represented as a number in the model
             * @param sTargetType the target type; may be "any", "float", "int", "string".  See {@link
             * sap.ui.model.odata.type} for more information.
             * @returns the formatted output value in the target type; <code>undefined</code> or <code>null</code> 
             * are formatted to <code>null</code>
            */
            formatValue(vValue: number | string, sTargetType: string): number | string;

            /**
             * Returns a metadata object for class sap.ui.model.odata.type.Double.
             * @returns Metadata object describing this class
            */
            getMetadata(): sap.ui.base.Metadata;

            /**
             * Returns the type's name.
             * @returns the type's name
            */
            getName(): string;

            /**
             * Parses the given value, which is expected to be of the given type, to an Edm.Double
             * in<code>number</code> representation.
             * @since 1.29.0
             * @param vValue the value to be parsed; the empty string and <code>null</code> are parsed to 
             * <code>null</code>; note that there is no way to enter <code>Infinity</code> or  <code>NaN</code>
             * values
             * @param sSourceType the source type (the expected type of <code>vValue</code>); may be "float", "int"
             * or  "string".  See {@link sap.ui.model.odata.type} for more information.
             * @returns the parsed value
            */
            parseValue(vValue: string | number, sSourceType: string): number;

            /**
             * Validates whether the given value in model representation is valid and meets thedefined constraints.
             * @since 1.29.0
             * @param fValue the value to be validated
            */
            validateValue(fValue: number): void;
          }
          /**
           * This class represents the OData primitive type
           * data.org/documentation/odata-version-2-0/overview#AbstractTypeSystem"><code>Edm.Single</code></a>.In
           * both {@link sap.ui.model.odata.v2.ODataModel} and {@link sap.ui.model.odata.v4.ODataModel}this type
           * is represented as a <code>number</code>.
           * @resource sap/ui/model/odata/type/Single.js
          */
          export class Single extends sap.ui.model.odata.type.ODataType {


            /**
             * Constructor for a primitive type <code>Edm.Single</code>.
             * @param oFormatOptions format options as defined in {@link sap.ui.core.format.NumberFormat}. In
             * contrast to  NumberFormat <code>groupingEnabled</code> defaults to <code>true</code>.
             * @param oConstraints constraints; {@link #validateValue validateValue} throws an error if any
             * constraint is  violated
            */
            constructor(oFormatOptions: any, oConstraints?: any);




            /**
             * Formats the given value to the given target type.
             * @param vValue the value to be formatted, which is represented as a number in the model
             * @param sTargetType the target type; may be "any", "float", "int", "string".  See {@link
             * sap.ui.model.odata.type} for more information.
             * @returns the formatted output value in the target type; <code>undefined</code> or <code>null</code> 
             * are formatted to <code>null</code>
            */
            formatValue(vValue: string | number, sTargetType: string): number | string;

            /**
             * Returns a metadata object for class sap.ui.model.odata.type.Single.
             * @returns Metadata object describing this class
            */
            getMetadata(): sap.ui.base.Metadata;

            /**
             * Returns the type's name.
             * @returns the type's name
            */
            getName(): string;

            /**
             * Parses the given value, which is expected to be of the given type, to an Edm.Single
             * in<code>number</code> representation.
             * @since 1.29.0
             * @param vValue the value to be parsed; the empty string and <code>null</code> are parsed to 
             * <code>null</code>; note that there is no way to enter <code>Infinity</code> or  <code>NaN</code>
             * values
             * @param sSourceType the source type (the expected type of <code>vValue</code>); may be "float", "int"
             *  or "string".  See {@link sap.ui.model.odata.type} for more information.
             * @returns the parsed value
            */
            parseValue(vValue: string | number, sSourceType: string): number;

            /**
             * Validates whether the given value in model representation is valid and meets thedefined constraints.
             * @since 1.29.0
             * @param fValue the value to be validated
            */
            validateValue(fValue: number): void;
          }
          /**
           * This class represents the OData primitive type
           * data.org/documentation/odata-version-2-0/overview#AbstractTypeSystem"><code>Edm.String</code></a>.In
           * both {@link sap.ui.model.odata.v2.ODataModel} and {@link sap.ui.model.odata.v4.ODataModel}this type
           * is represented as a <code>string</code>.
           * @resource sap/ui/model/odata/type/String.js
          */
          export class String extends sap.ui.model.odata.type.ODataType {


            /**
             * Constructor for an OData primitive type <code>Edm.String</code>.
             * @param oFormatOptions format options as defined in the interface of {@link sap.ui.model.SimpleType};
             * this  type ignores them since it does not support any format options
             * @param oConstraints constraints; {@link #validateValue validateValue} throws an error if any
             * constraint is  violated
            */
            constructor(oFormatOptions: any, oConstraints?: any);




            /**
             * Formats the given value to the given target type.If <code>isDigitSequence</code> constraint of this
             * type is set to <code>true</code> and thetarget type is any or string and the given value contains
             * only digits, the leading zeros aretruncated.
             * @param sValue the value to be formatted
             * @param sTargetType the target type; may be "any", "boolean", "float", "int" or "string".  See {@link
             * sap.ui.model.odata.type} for more information.
             * @returns the formatted output value in the target type; <code>undefined</code> is always formatted 
             * to <code>null</code>; <code>null</code> is formatted to "" if the target type is "string".
            */
            formatValue(sValue: string, sTargetType: string): string | number | boolean;

            /**
             * Returns a metadata object for class sap.ui.model.odata.type.String.
             * @returns Metadata object describing this class
            */
            getMetadata(): sap.ui.base.Metadata;

            /**
             * Returns the type's name.
             * @returns the type's name
            */
            getName(): string;

            /**
             * Parses the given value which is expected to be of the given type to a string.If
             * <code>isDigitSequence</code> constraint of this type is set to <code>true</code> andthe parsed
             * string is a sequence of digits, then the parsed string is either enhanced withleading zeros, if
             * <code>maxLength</code> constraint is given, or leading zeros are removedfrom parsed string.
             * @param vValue the value to be parsed, maps <code>""</code> to <code>null</code>
             * @param sSourceType the source type (the expected type of <code>vValue</code>).  See {@link
             * sap.ui.model.odata.type} for more information.
             * @returns the parsed value
            */
            parseValue(vValue: string | number | boolean, sSourceType: string): string;

            /**
             * Validates whether the given value in model representation is valid and meets thedefined constraints.
             * @param sValue the value to be validated
            */
            validateValue(sValue: string): void;
          }
          /**
           * This class represents the OData primitive type
           * ata.org/documentation/odata-version-2-0/overview#AbstractTypeSystem"><code>Edm.Boolean</code></a>.In
           * both {@link sap.ui.model.odata.v2.ODataModel} and {@link sap.ui.model.odata.v4.ODataModel}this type
           * is represented as a <code>boolean</code>.
           * @resource sap/ui/model/odata/type/Boolean.js
          */
          export class Boolean extends sap.ui.model.odata.type.ODataType {


            /**
             * Constructor for an OData primitive type <code>Edm.Boolean</code>.
             * @param oFormatOptions format options as defined in the interface of {@link sap.ui.model.SimpleType};
             * this  type ignores them since it does not support any format options
             * @param oConstraints constraints; {@link #validateValue validateValue} throws an error if any
             * constraint is  violated
            */
            constructor(oFormatOptions: any, oConstraints?: any);




            /**
             * Formats the given boolean value to the given target type.
             * @param bValue the value to be formatted
             * @param sTargetType the target type; may be "any", "boolean" or "string". If it is "string", the
             * result is  "Yes" or "No" in the current {@link sap.ui.core.Configuration#getLanguage language}.  See
             * {@link sap.ui.model.odata.type} for more information.
             * @returns the formatted output value in the target type; <code>undefined</code> or <code>null</code> 
             * are formatted to <code>null</code>
            */
            formatValue(bValue: boolean, sTargetType: string): boolean | string;

            /**
             * Returns a metadata object for class sap.ui.model.odata.type.Boolean.
             * @returns Metadata object describing this class
            */
            getMetadata(): sap.ui.base.Metadata;

            /**
             * Returns the type's name.
             * @returns the type's name
            */
            getName(): string;

            /**
             * Parses the given value from the given type to a boolean.
             * @param vValue the value to be parsed; the empty string and <code>null</code> are parsed to 
             * <code>null</code>
             * @param sSourceType the source type (the expected type of <code>vValue</code>); may be "boolean" or
             * "string".  See {@link sap.ui.model.odata.type} for more information.
             * @returns the parsed value
            */
            parseValue(vValue: boolean | string, sSourceType: string): boolean;

            /**
             * Validates whether the given value in model representation is valid and meets the givenconstraints.
             * @param bValue the value to be validated
            */
            validateValue(bValue: boolean): void;
          }
          /**
           * This class represents the OData primitive type
           * ata.org/documentation/odata-version-2-0/overview#AbstractTypeSystem"><code>Edm.Decimal</code></a>.In
           * both {@link sap.ui.model.odata.v2.ODataModel} and {@link sap.ui.model.odata.v4.ODataModel}this type
           * is represented as a <code>string</code>. It never uses exponential format ("1e-5").
           * @resource sap/ui/model/odata/type/Decimal.js
          */
          export class Decimal extends sap.ui.model.odata.type.ODataType {


            /**
             * Constructor for a primitive type <code>Edm.Decimal</code>.
             * @param oFormatOptions format options as defined in {@link sap.ui.core.format.NumberFormat}. In
             * contrast to  NumberFormat <code>groupingEnabled</code> defaults to <code>true</code>.  Note that
             * <code>maxFractionDigits</code> and <code>minFractionDigits</code> are set to  the value of the
             * constraint <code>scale</code> unless it is "variable". They can however  be overwritten.
             * @param oConstraints constraints; {@link #validateValue validateValue} throws an error if any
             * constraint is  violated
            */
            constructor(oFormatOptions: any, oConstraints?: any);




            /**
             * Formats the given value to the given target type. When formatting to "string" the type'sconstraint
             * <code>scale</code> is taken into account.
             * @param sValue the value to be formatted, which is represented as a string in the model
             * @param sTargetType the target type; may be "any", "float", "int" or "string".  See {@link
             * sap.ui.model.odata.type} for more information.
             * @returns the formatted output value in the target type; <code>undefined</code> or <code>null</code> 
             * are formatted to <code>null</code>
            */
            formatValue(sValue: string, sTargetType: string): number | string;

            /**
             * Returns a metadata object for class sap.ui.model.odata.type.Decimal.
             * @returns Metadata object describing this class
            */
            getMetadata(): sap.ui.base.Metadata;

            /**
             * Returns the type's name.
             * @returns the type's name
            */
            getName(): string;

            /**
             * Parses the given value, which is expected to be of the given type, to a decimal
             * in<code>string</code> representation.
             * @param vValue the value to be parsed; the empty string and <code>null</code> are parsed to 
             * <code>null</code>
             * @param sSourceType the source type (the expected type of <code>vValue</code>); may be "float", "int"
             * or  "string".  See {@link sap.ui.model.odata.type} for more information.
             * @returns the parsed value
            */
            parseValue(vValue: string | number, sSourceType: string): string;

            /**
             * Validates whether the given value in model representation is valid and meets thedefined constraints.
             * @param sValue the value to be validated
            */
            validateValue(sValue: string): void;
          }
          /**
           * This class represents the OData V2 primitive type
           * ta.org/documentation/odata-version-2-0/overview#AbstractTypeSystem"><code>Edm.DateTime</code></a>.If
           * you want to display a date and a time, prefer {@linksap.ui.model.odata.type.DateTimeOffset},
           * specifically designed for this purpose.Use <code>DateTime</code> with the SAP-specific annotation
           * <code>display-format=Date</code>(resp. the constraint <code>displayFormat: "Date"</code>) to display
           * only a date.In {@link sap.ui.model.odata.v2.ODataModel} this type is represented as
           * a<code>Date</code>. With the constraint <code>displayFormat: "Date"</code>, the time zone isUTF and
           * the time part is ignored, otherwise it is a date/time value in local time.
           * @resource sap/ui/model/odata/type/DateTime.js
          */
          export class DateTime extends sap.ui.model.odata.type.DateTimeBase {


            /**
             * Constructor for a primitive type <code>Edm.DateTime</code>.
             * @param oFormatOptions format options as defined in {@link sap.ui.core.format.DateFormat}
             * @param oConstraints constraints; {@link sap.ui.model.odata.type.DateTimeBase#validateValue
             * validateValue}  throws an error if any constraint is violated
            */
            constructor(oFormatOptions: any, oConstraints?: any);




            /**
             * Returns a metadata object for class sap.ui.model.odata.type.DateTime.
             * @returns Metadata object describing this class
            */
            getMetadata(): sap.ui.base.Metadata;

            /**
             * Returns the type's name.
             * @returns the type's name
            */
            getName(): string;
          }
          /**
           * This class represents the OData V4 primitive type {@link 
           * s/complete/part3-csdl/odata-v4.0-errata02-os-part3-csdl-complete.html#_The_edm:Documentation_Element
           *  <code>Edm.TimeOfDay</code>}.  In {@link sap.ui.model.odata.v4.ODataModel} this type is represented
           * as a  <code>string</code>.
           * @resource sap/ui/model/odata/type/TimeOfDay.js
          */
          export class TimeOfDay extends sap.ui.model.odata.type.ODataType {


            /**
             * Constructor for an OData primitive type <code>Edm.TimeOfDay</code>.
             * @param oFormatOptions Format options as defined in {@link sap.ui.core.format.DateFormat}
             * @param oConstraints Constraints; {@link #validateValue validateValue} throws an error if any
             * constraint is  violated
            */
            constructor(oFormatOptions: any, oConstraints?: any);




            /**
             * Formats the given value to the given target type.
             * @since 1.37.0
             * @param sValue The value to be formatted, which is represented as a string in the model
             * @param sTargetType The target type, may be "any" or "string"; see {@link sap.ui.model.odata.type}
             * for more  information
             * @returns The formatted output value in the target type; <code>undefined</code> or <code>null</code> 
             * are formatted to <code>null</code>
            */
            formatValue(sValue: string, sTargetType: string): string;

            /**
             * Returns a metadata object for class sap.ui.model.odata.type.TimeOfDay.
             * @returns Metadata object describing this class
            */
            getMetadata(): sap.ui.base.Metadata;

            /**
             * Returns the type's name.
             * @since 1.37.0
             * @returns The type's name
            */
            getName(): string;

            /**
             * Parses the given value, which is expected to be of the given type, to a string with anOData V4
             * Edm.TimeOfDay value.
             * @since 1.37.0
             * @param sValue The value to be parsed, maps <code>""</code> to <code>null</code>
             * @param sSourceType The source type (the expected type of <code>sValue</code>), must be "string"; see
             *  {@link sap.ui.model.odata.type} for more information.
             * @returns The parsed value
            */
            parseValue(sValue: string, sSourceType: string): string;

            /**
             * Validates the given value in model representation and meets the type's constraints.
             * @since 1.37.0
             * @param sValue The value to be validated
            */
            validateValue(sValue: string): void;
          }
          /**
           * This class is an abstract base class for all OData primitive types (see
           * plete/part3-csdl/odata-v4.0-errata02-os-part3-csdl-complete.html#_The_edm:Documentation_ElementOData
           * V4 Edm Types} and{@link
           * http://www.odata.org/documentation/odata-version-2-0/overview#AbstractTypeSystemOData V2 Edm
           * Types}). All subtypes implement the interface of{@link sap.ui.model.SimpleType}. That means they
           * implement next to the constructor:<ul><li>{@link sap.ui.model.SimpleType#getName
           * getName}</li><li>{@link sap.ui.model.SimpleType#formatValue formatValue}</li><li>{@link
           * sap.ui.model.SimpleType#parseValue parseValue}</li><li>{@link sap.ui.model.SimpleType#validateValue
           * validateValue}</li></ul>All ODataTypes are immutable. All format options and constraints are given
           * to theconstructor, they cannot be modified later.All ODataTypes use a locale-specific message when
           * throwing an error caused by invaliduser input (e.g. if {@link
           * sap.ui.model.odata.type.Double#parseValue Double.parseValue}cannot parse the given value to a
           * number, or if any type's {@link #validateValuevalidateValue} gets a <code>null</code>, but the
           * constraint <code>nullable</code> is<code>false</code>).
           * @resource sap/ui/model/odata/type/ODataType.js
          */
          export class ODataType extends sap.ui.model.SimpleType {


            /**
             * Constructor for a new <code>ODataType</code>.
             * @param oFormatOptions type-specific format options; see subtypes
             * @param oConstraints type-specific constraints (e.g. <code>oConstraints.nullable</code>), see
             * subtypes
            */
            constructor(oFormatOptions: any, oConstraints?: any);




            /**
             * @returns this
            */
            getInterface(): sap.ui.base.Interface;

            /**
             * Returns a metadata object for class sap.ui.model.odata.type.ODataType.
             * @returns Metadata object describing this class
            */
            getMetadata(): sap.ui.base.Metadata;
          }
          /**
           * This is an abstract base class for the OData primitive types  <code>Edm.DateTime</code> and
           * <code>Edm.DateTimeOffset</code>.
           * @resource sap/ui/model/odata/type/DateTimeBase.js
          */
          export abstract class DateTimeBase extends sap.ui.model.odata.type.ODataType {


            /**
             * Base constructor for the primitive types <code>Edm.DateTime</code>
             * and<code>Edm.DateTimeOffset</code>.
             * @param oFormatOptions Type-specific format options; see subtypes
             * @param oConstraints Constraints; {@link #validateValue validateValue} throws an error if any
             * constraint is  violated
            */
            constructor(oFormatOptions: any, oConstraints?: any);




            /**
             * Formats the given value to the given target type.
             * @since 1.27.0
             * @param oValue The value to be formatted, which is represented in the model as a <code>Date</code> 
             * instance (OData V2)
             * @param sTargetType The target type, may be "any" or "string"; see {@link sap.ui.model.odata.type}
             * for more  information
             * @returns The formatted output value in the target type; <code>undefined</code> or <code>null</code> 
             * are formatted to <code>null</code>
            */
            formatValue(oValue: Date, sTargetType: string): Date | string;

            /**
             * Returns a metadata object for class sap.ui.model.odata.type.DateTimeBase.
             * @returns Metadata object describing this class
            */
            getMetadata(): sap.ui.base.Metadata;

            /**
             * Parses the given value to a <code>Date</code> instance (OData V2).
             * @since 1.27.0
             * @param sValue The value to be parsed; the empty string and <code>null</code> are parsed to 
             * <code>null</code>
             * @param sSourceType The source type (the expected type of <code>sValue</code>), must be "string"; see
             *  {@link sap.ui.model.odata.type} for more information
             * @returns The parsed value
            */
            parseValue(sValue: string, sSourceType: string): Date | string;

            /**
             * Validates whether the given value in model representation is valid and meets thedefined constraints.
             * @since 1.27.0
             * @param oValue The value to be validated
            */
            validateValue(oValue: Date): void;
          }
          /**
           * This class represents the OData primitive type <a 
           * href="http://www.odata.org/documentation/odata-version-2-0/overview#AbstractTypeSystem"> 
           * <code>Edm.DateTimeOffset</code></a>.  In {@link sap.ui.model.odata.v2.ODataModel} this type is
           * represented as a  <code>Date</code> instance in local time. In {@link
           * sap.ui.model.odata.v4.ODataModel} this  type is represented as a <code>string</code> like
           * "2014-11-27T13:47:26Z". See parameter  <code>oConstraints.V4</code> for more information.
           * @resource sap/ui/model/odata/type/DateTimeOffset.js
          */
          export class DateTimeOffset extends sap.ui.model.odata.type.DateTimeBase {


            /**
             * Constructor for a primitive type <code>Edm.DateTimeOffset</code>.
             * @param oFormatOptions Format options as defined in {@link sap.ui.core.format.DateFormat}
             * @param oConstraints Constraints; {@link sap.ui.model.odata.type.DateTimeBase#validateValue
             * validateValue}  throws an error if any constraint is violated
            */
            constructor(oFormatOptions: any, oConstraints?: any);



            /**
             * Formats the given value to the given target type.
             * @since 1.27.0
             * @param vValue The value to be formatted, which is represented in the model as a <code>Date</code> 
             * instance (OData V2) or as a string like "2014-11-27T13:47:26Z" (OData V4); both  representations are
             * accepted independent of the model's OData version
             * @param sTargetType The target type, may be "any" or "string"; see {@link sap.ui.model.odata.type}
             * for more  information
             * @returns The formatted output value in the target type; <code>undefined</code> or <code>null</code> 
             * are formatted to <code>null</code>
            */
            formatValue(vValue: Date | string, sTargetType: string): Date | string;

            /**
             * Returns the type's name.
             * @returns The type's name
            */
            getName(): string;

            /**
             * Parses the given value to a <code>Date</code> instance (OData V2) or a string
             * like"2014-11-27T13:47:26Z" (OData V4), depending on the model's OData version.
             * @since 1.27.0
             * @param sValue The value to be parsed; the empty string and <code>null</code> are parsed to 
             * <code>null</code>
             * @param sSourceType The source type (the expected type of <code>sValue</code>), must be "string"; see
             *  {@link sap.ui.model.odata.type} for more information
             * @returns The parsed value
            */
            parseValue(sValue: string, sSourceType: string): Date | string;

            /**
             * Validates whether the given value in model representation is valid and meets thedefined constraints,
             * depending on the model's OData version.
             * @since 1.27.0
             * @param vValue The value to be validated
            */
            validateValue(vValue: any): void;
          }
        }
        namespace BatchMode {

          /**
           * Batch grouping enabled
          */
          var Group: any;

          /**
           * No batch requests
          */
          var None: any;
        }
        namespace CountMode {

          /**
           * Count is retrieved by a separate request upfront and inline with each data request
          */
          var Both: any;

          /**
           * Count is retrieved by adding $inlinecount=allpages and is included in the data request
          */
          var Inline: any;

          /**
           * Count is retrieved by adding $inlinecount=allpages and is included in every data request
          */
          var InlineRepeat: any;

          /**
           * Count is not requested from the server
          */
          var None: any;

          /**
           * Count is retrieved by sending a separate $count request, before requesting data
          */
          var Request: any;
        }
        namespace ODataUtils {

          /**
           * Compares the given OData values based on their type. All date and time types can also becompared
           * with a number. This number is then interpreted as the number of milliseconds thatthe corresponding
           * date or time object should hold.
           * @since 1.29.1
           * @param vValue1 the first value to compare
           * @param vValue2 the second value to compare
           * @param bAsDecimal if <code>true</code>, the string values <code>vValue1</code> and
           * <code>vValue2</code> are  compared as a decimal number (only sign, integer and fraction digits; no
           * exponential  format). Otherwise they are recognized by looking at their types.
           * @returns the result of the compare: <code>0</code> if the values are equal, <code>-1</code> if the 
           * first value is smaller, <code>1</code> if the first value is larger, <code>NaN</code> if  they
           * cannot be compared
          */
          function compare(vValue1: any, vValue2: any, bAsDecimal?: string): number;

          /**
           * Formats a JavaScript value according to the given<a
           * href="http://www.odata.org/documentation/odata-version-2-0/overview#AbstractTypeSystem">EDM
           * type</a>.
           * @param vValue the value to format
           * @param sType the EDM type (e.g. Edm.Decimal)
           * @returns the formatted value
          */
          function formatValue(vValue: any, sType: string): string;

          /**
           * Returns a comparator function optimized for the given EDM type.
           * @since 1.29.1
           * @param sEdmType the EDM type
           * @returns the comparator function taking two values of the given type and returning <code>0</code> 
           * if the values are equal, <code>-1</code> if the first value is smaller, <code>1</code> if  the first
           * value is larger and <code>NaN</code> if they cannot be compared (e.g. one value  is
           * <code>null</code> or <code>undefined</code>)
          */
          function getComparator(sEdmType: string): any;

          /**
           * Adds an origin to the given service URL.If an origin is already present, it will only be replaced if
           * the parameters object contains the flag "force: true".In case the URL already contains URL
           * parameters, these will be kept.As a parameter, a sole alias is sufficient. The parameters
           * vParameters.system and vParameters.client however have to be given in pairs.In case all three origin
           * specifying parameters are given (system/client/alias), the alias has
           * precedence.Examples:setOrigin("/backend/service/url/", "DEMO_123");- result:
           * /backend/service/url;o=DEMO_123/setOrigin("/backend/service/url;o=OTHERSYS8?myUrlParam=true&x=4",
           * {alias: "DEMO_123", force: true});- result
           * /backend/service/url;o=DEMO_123?myUrlParam=true&x=4setOrigin("/backend/service/url/", {system:
           * "DEMO", client: 134});- result /backend/service/url;o=sid(DEMO.134)/
           * @since 1.30.7
           * @param sServiceURL the URL which will be enriched with an origin
           * @param vParameters if string then it is asumed its the system alias, else if the argument is an
           * object then additional Parameters can be given
           * @returns the service URL with the added origin.
          */
          function setOrigin(sServiceURL: string, vParameters: any | string): string;
        }
        namespace UpdateMethod {

          /**
           * MERGE method will send update requests in a MERGE request
          */
          var Merge: any;

          /**
           * PUT method will send update requests in a PUT request
          */
          var Put: any;
        }
        namespace OperationMode {

          /**
           * With OperationMode "Auto", operations are either processed on the client or on the server, depending
           * on the given binding threshold.Please be aware, that the combination of OperationMode.Auto and
           * CountMode.None is not supported.There are two possibilities which can happen, when using the "Auto"
           * mode, depending on the configured "CountMode":1. CountMode "Request" and "Both"Initially the binding
           * will issue a $count request without any filters/sorters.a) If the count is lower or equal to the
           * threshold, the binding will behave like in operation mode "Client", and a data request for all
           * entries is issued.b) If the count exceeds the threshold, the binding will behave like in operation
           * mode "Server".2. CountModes "Inline" or "InlineRepeat"The initial request tries to fetch as many
           * entries as the configured threshold, without any filters/sorters. In addition a $inlinecount is
           * added.The binding assumes, that the threshold given by the application can be met. If this is not
           * the case additional data requests might be needed.So the application has to have the necessary
           * confidence that the threshold is high enough to make sure, that the data is not requested twice.a)
           * If this request returns fewer (or just as many) entries as the threshold, the binding will behave
           * exactly like when usingthe "Client" operation mode. Initially configured filters/sorters will be
           * applied afterwards on the client.b) If the $inlinecount is higher than the threshold, the binding
           * will behave like in operation mode "Server". In this case a new data requestcontaining the initially
           * set filters/sorters will be issued.
          */
          var Auto: any;

          /**
           * Operations are executed on the client, all entries must be avilable to be able to do so.The initial
           * request fetches the complete collection, filtering and sorting does not trigger further requests
          */
          var Client: any;

          /**
           * Operations are executed on the Odata service, by appending corresponding URL parameters ($filter,
           * $orderby).Each change in filtering or sorting is triggering a new request to the server.
          */
          var Server: any;
        }
        namespace AnnotationHelper {

          /**
           * Creates a property setting (which is either a constant value or a binding infoobject) from the given
           * parts and from the optional root formatter function.Each part can have one of the following
           * types:<ul>  <li><code>boolean</code>, <code>number</code>, <code>undefined</code>: The part is  a
           * constant value.  <li><code>string</code>: The part is a data binding expression with complex 
           * binding syntax (for example, as created by {@link #.format format}) and is parsed  accordingly to
           * create either a constant value or a binding info object. Proper  backslash escaping must be used for
           * constant values with curly braces.  <li><code>object</code>: The part is a binding info object if it
           * has a "path" or  "parts" property, otherwise it is a constant value.</ul>If a binding info object is
           * not the only part and has a "parts" property itself,then it must have no other properties except
           * "formatter"; this is the case forexpression bindings and data binding expressions created by {@link
           * #.format format}.If all parts are constant values, the resulting property setting is also a
           * constantvalue computed by applying the root formatter function to the constant parts once.If at
           * least one part is a binding info object, the resulting property setting isalso a binding info object
           * and the root formatter function will be applied again andagain to the current values of all parts,
           * no matter whether constant or variable.Note: The root formatter function should not rely on its
           * <code>this</code> valuebecause it depends on how the function is called.Note: A single data binding
           * expression can be given directly to{@link sap.ui.base.ManagedObject#applySettings applySettings}, no
           * need to call thisfunction first.Example:<pre>function myRootFormatter(oValue1, oValue2, sFullName,
           * sGreeting, iAnswer) {    return ...; //TODO compute something useful from the given
           * values}oSupplierContext =
           * oMetaModel.getMetaContext("/ProductSet('HT-1021')/ToSupplier");oValueContext =
           * oMetaModel.createBindingContext("com.sap.vocabularies.UI.v1.DataPoint/Value",
           * oSupplierContext);vPropertySetting =  sap.ui.model.odata.AnnotationHelper.createPropertySetting([   
           * sap.ui.model.odata.AnnotationHelper.format(oValueContext),    "{path : 'meta>Value', formatter :
           * 'sap.ui.model.odata.AnnotationHelper.simplePath'}",    "{:= 'Mr. ' + ${/FirstName} + ' ' +
           * ${/LastName}}",    "hello, world!",    42], myRootFormatter);oControl.applySettings({"someProperty"
           * : vPropertySetting});</pre>
           * @since 1.31.0
           * @param vParts array of parts
           * @param fnRootFormatter root formatter function; default: <code>Array.prototype.join(., " ")</code> 
           * in case of multiple parts, just like  {@link sap.ui.model.CompositeBinding#getExternalValue
           * getExternalValue}
           * @returns constant value or binding info object for a property as expected by  {@link
           * sap.ui.base.ManagedObject#applySettings applySettings}
          */
          function createPropertySetting(vParts: any[], fnRootFormatter?: any): any | any;

          /**
           * A formatter function to be used in a complex binding inside an XML template viewin order to
           * interpret OData V4 annotations. It knows about<ul>  <li> the "14.4 Constant Expressions" for
           * "edm:Bool", "edm:Date",  "edm:DateTimeOffset", "edm:Decimal", "edm:Float", "edm:Guid", "edm:Int", 
           * "edm:TimeOfDay".  <li> the constant "14.4.11 Expression edm:String": This is turned into a fixed 
           * text (e.g. <code>"Width"</code>) or into a data binding expression (e.g. <code> 
           * ervices/schema/0/entityType/1/com.sap.vocabularies.UI.v1.FieldGroup#Dimensions/Data/0/Label/String}"
           *  </code>). Data binding expressions are used in case XML template processing has  been started with
           * the setting <code>bindTexts : true</code>. The purpose is to  reference translatable texts from
           * OData V4 annotations, especially for XML  template processing at design time. Since 1.31.0, string
           * constants that contain a  simple binding <code>"{@i18n>...}"</code> to the hard-coded model name
           * "@i18n"  with arbitrary path are not turned into a fixed text, but kept as a data binding 
           * expression; this allows local annotation files to refer to a resource bundle for 
           * internationalization.  <li> the dynamic "14.5.1 Comparison and Logical Operators": These are turned
           * into  expression bindings to perform the operations at run-time.  <li> the dynamic "14.5.3
           * Expression edm:Apply":  <ul>    <li> "14.5.3.1.1 Function odata.concat": This is turned into a data
           * binding    expression relative to an entity.    <li> "14.5.3.1.2 Function odata.fillUriTemplate":
           * This is turned into an    expression binding to fill the template at run-time.    <li> "14.5.3.1.3
           * Function odata.uriEncode": This is turned into an expression    binding to encode the parameter at
           * run-time.    <li> Apply functions may be nested arbitrarily.  </ul>  <li> the dynamic "14.5.6
           * Expression edm:If": This is turned into an expression  binding to be evaluated at run-time. The
           * expression is a conditional expression  like <code>"{=condition ? expression1 :
           * expression2}"</code>.  <li> the dynamic "14.5.10 Expression edm:Null": This is turned into a 
           * <code>null</code> value. In <code>odata.concat</code> it is ignored.  <li> the dynamic "14.5.12
           * Expression edm:Path" and "14.5.13 Expression  edm:PropertyPath": This is turned into a data binding
           * relative to an entity,  including type information and constraints as available from meta data, 
           * e.g. <code>"{path : 'Name', type : 'sap.ui.model.odata.type.String',  constraints :
           * {'maxLength':'255'}}"</code>.  Depending on the used type, some additional constraints of this type
           * are set:  <ul>    <li>Edm.DateTime: The "displayFormat" constraint is set to the value of the   
           * "sap:display-format" annotation of the referenced property.    <li>Edm.Decimal: The "precision" and
           * "scale" constraints are set to the values    of the corresponding attributes of the referenced
           * property.    <li>Edm.String: The "maxLength" constraint is set to the value of the    corresponding
           * attribute of the referenced property and the "isDigitSequence"    constraint is set to the value of
           * the    "com.sap.vocabularies.Common.v1.IsDigitSequence" annotation of the referenced    property. 
           * </ul></ul>Unsupported or incorrect values are turned into a string nevertheless, but indicatedas
           * such. Proper escaping is used to make sure that data binding syntax is notcorrupted. An error
           * describing the problem is logged to the console in such a case.Example:<pre>&lt;Text text="{path:
           * 'meta>Value', formatter: 'sap.ui.model.odata.AnnotationHelper.format'}" /></pre>
           * @param oInterface the callback interface related to the current formatter call
           * @param vRawValue the raw value from the meta model, which is embedded within an entity set or 
           * entity type:  <ul>  <li>if this function is used as formatter the value  is provided by the
           * framework</li>  <li>if this function is called directly, provide the parameter only if it is 
           * already calculated</li>  <li>if the parameter is omitted, it is calculated automatically through 
           * <code>oInterface.getObject("")</code></li>  </ul>
           * @returns the resulting string value to write into the processed XML
          */
          function format(oInterface: sap.ui.core.util.XMLPreprocessor.IContext | sap.ui.model.Context, vRawValue?: any): string;

          /**
           * A formatter function to be used in a complex binding inside an XML template viewin order to
           * interpret OData V4 annotations. It knows about the following dynamicexpressions:<ul><li>"14.5.2
           * Expression edm:AnnotationPath"</li><li>"14.5.11 Expression
           * edm:NavigationPropertyPath"</li><li>"14.5.12 Expression edm:Path"</li><li>"14.5.13 Expression
           * edm:PropertyPath"</li></ul>It returns a binding expression for a navigation path in an OData model,
           * starting atan entity.Currently supports navigation properties. Term casts and annotations
           * ofnavigation properties terminate the navigation path.Examples:<pre>&lt;template:if test="{path:
           * 'facet>Target', formatter: 'sap.ui.model.odata.AnnotationHelper.getNavigationPath'}">   
           * &lt;form:SimpleForm binding="{path: 'facet>Target', formatter:
           * 'sap.ui.model.odata.AnnotationHelper.getNavigationPath'}" />&lt;/template:if></pre>
           * @param oInterface the callback interface related to the current formatter call
           * @param vRawValue the raw value from the meta model, e.g. <code>{AnnotationPath : 
           * "ToSupplier/@com.sap.vocabularies.Communication.v1.Address"}</code> or <code>  {AnnotationPath :
           * "@com.sap.vocabularies.UI.v1.FieldGroup#Dimensions"}</code>;  embedded within an entity set or
           * entity type;  <ul>  <li>if this function is used as formatter the value  is provided by the
           * framework</li>  <li>if this function is called directly, provide the parameter only if it is 
           * already calculated</li>  <li>if the parameter is omitted, it is calculated automatically through 
           * <code>oInterface.getObject("")</code></li>  </ul>
           * @returns the resulting string value to write into the processed XML, e.g. "{ToSupplier}"  or "{}"
           * (in case no navigation is needed); returns "" in case the navigation path  cannot be determined
           * (this is treated as falsy in <code>template:if</code>  statements!)
          */
          function getNavigationPath(oInterface: sap.ui.core.util.XMLPreprocessor.IContext | sap.ui.model.Context, vRawValue?: any): string;

          /**
           * Helper function for a <code>template:with</code> instruction that depending on howit is called goes
           * to the entity set with the given name or to the one determinedby the last navigation property.
           * Supports the following dynamic expressions:<ul><li>"14.5.2 Expression
           * edm:AnnotationPath"</li><li>"14.5.11 Expression edm:NavigationPropertyPath"</li><li>"14.5.12
           * Expression edm:Path"</li><li>"14.5.13 Expression edm:PropertyPath"</li></ul>Example:<pre> 
           * &lt;template:with path="facet>Target" helper="sap.ui.model.odata.AnnotationHelper.gotoEntitySet"
           * var="entitySet"/>  &lt;template:with path="associationSetEnd>entitySet"
           * helper="sap.ui.model.odata.AnnotationHelper.gotoEntitySet" var="entitySet"/></pre>
           * @param oContext a context which must point to a simple string or to an annotation (or annotation 
           * property) of type <code>Edm.AnnotationPath</code>,  <code>Edm.NavigationPropertyPath</code>,
           * <code>Edm.Path</code>, or  <code>Edm.PropertyPath</code> embedded within an entity set or entity
           * type;  the context's model must be an {@link sap.ui.model.odata.ODataMetaModel}
           * @returns the path to the entity set, or <code>undefined</code> if no such set is found. In  this
           * case, a warning is logged to the console.
          */
          function gotoEntitySet(oContext: sap.ui.model.Context): string;

          /**
           * Helper function for a <code>template:with</code> instruction that goes to theentity type with the
           * qualified name which <code>oContext</code> points at.Example: Assume that "entitySet" refers to an
           * entity set within an OData meta model;the helper function is then called on the "entityType"
           * property of that entity set(which holds the qualified name of the entity type) and in turn the path
           * of thatentity type is assigned to the variable "entityType".<pre>  &lt;template:with
           * path="entitySet>entityType" helper="sap.ui.model.odata.AnnotationHelper.gotoEntityType"
           * var="entityType"></pre>
           * @param oContext a context which must point to the qualified name of an entity type;  the context's
           * model must be an {@link sap.ui.model.odata.ODataMetaModel}
           * @returns the path to the entity type with the given qualified name,  or <code>undefined</code> if no
           * such type is found. In this case, a warning is  logged to the console.
          */
          function gotoEntityType(oContext: sap.ui.model.Context): string;

          /**
           * Helper function for a <code>template:with</code> instruction that goes to thefunction import with
           * the name which <code>oContext</code> points at.Example: Assume that "dataField" refers to a
           * DataFieldForAction within anOData meta model;the helper function is then called on the "Action"
           * property of that data field(which holds an object with the qualified name of the function import in
           * the<code>String</code> property) and in turn the path of that function importis assigned to the
           * variable "function".<pre>  &lt;template:with path="dataField>Action" 
           * helper="sap.ui.model.odata.AnnotationHelper.gotoFunctionImport" var="function"></pre>
           * @since 1.29.1
           * @param oContext a context which must point to an object with a <code>String</code> property, which 
           * holds the qualified name of the function import;  the context's model must be an {@link
           * sap.ui.model.odata.ODataMetaModel}
           * @returns the path to the function import with the given qualified name,  or <code>undefined</code>
           * if no function import is found. In this case, a warning  is logged to the console.
          */
          function gotoFunctionImport(oContext: sap.ui.model.Context): string;

          /**
           * A formatter function to be used in a complex binding inside an XML template viewin order to
           * interpret OData V4 annotations. It knows about the following dynamicexpressions:<ul><li>"14.5.2
           * Expression edm:AnnotationPath"</li><li>"14.5.11 Expression
           * edm:NavigationPropertyPath"</li><li>"14.5.12 Expression edm:Path"</li><li>"14.5.13 Expression
           * edm:PropertyPath"</li></ul>It returns the information whether the navigation path ends with an
           * association endwith multiplicity "*". It throws an error if the navigation path has an
           * associationend with multiplicity "*" which is not the last one.Currently supports navigation
           * properties. Term casts and annotations ofnavigation properties terminate the navigation
           * path.Examples:<pre>&lt;template:if test="{path: 'facet>Target', formatter:
           * 'sap.ui.model.odata.AnnotationHelper.isMultiple'}"></pre>
           * @param oInterface the callback interface related to the current formatter call
           * @param vRawValue the raw value from the meta model, e.g. <code>{AnnotationPath : 
           * "ToSupplier/@com.sap.vocabularies.Communication.v1.Address"}</code> or <code>  {AnnotationPath :
           * "@com.sap.vocabularies.UI.v1.FieldGroup#Dimensions"}</code>;  embedded within an entity set or
           * entity type;  <ul>  <li>if this function is used as formatter the value  is provided by the
           * framework</li>  <li>if this function is called directly, provide the parameter only if it is 
           * already calculated</li>  <li>if the parameter is omitted, it is calculated automatically through 
           * <code>oInterface.getObject("")</code></li>  </ul>
           * @returns <code>"true"</code> if the navigation path ends with an association end with   multiplicity
           * "*", <code>""</code> in case the navigation path cannot be   determined, <code>"false"</code>
           * otherwise (the latter are both treated as falsy   in <code>template:if</code> statements!)
          */
          function isMultiple(oInterface: sap.ui.core.util.XMLPreprocessor.IContext | sap.ui.model.Context, vRawValue?: any): string;

          /**
           * Helper function for a <code>template:with</code> instruction that resolves a dynamic"14.5.2
           * Expression edm:AnnotationPath","14.5.11 Expression edm:NavigationPropertyPath", "14.5.12 Expression
           * edm:Path" or"14.5.13 Expression edm:PropertyPath".Currently supports navigation properties and term
           * casts.Example:<pre>  &lt;template:with path="meta>Value"
           * helper="sap.ui.model.odata.AnnotationHelper.resolvePath" var="target"></pre>
           * @param oContext a context which must point to an annotation or annotation property of type 
           * <code>Edm.AnnotationPath</code>, <code>Edm.NavigationPropertyPath</code>,  <code>Edm.Path</code> or
           * <code>Edm.PropertyPath</code>, embedded within an entity  set or entity type;  the context's model
           * must be an {@link sap.ui.model.odata.ODataMetaModel}
           * @returns the path to the target, or <code>undefined</code> in case the path cannot be  resolved. In
           * this case, a warning is logged to the console.
          */
          function resolvePath(oContext: sap.ui.model.Context): string;

          /**
           * Formatter function that is used in a complex binding inside an XML template view.The function is
           * used to interpret OData V4 annotations, supporting the sameannotations as {@link #.format format}
           * but with a simplified output aimed atdesign-time templating with smart controls.In contrast to
           * <code>format</code>, "14.5.12 Expression edm:Path" or"14.5.13 Expression edm:PropertyPath" is turned
           * into a simple binding path withouttype or constraint information. In certain cases, a complex
           * binding is required toallow for proper escaping of the path.Example:<pre>  &lt;sfi:SmartField
           * value="{path: 'meta>Value', formatter: 'sap.ui.model.odata.AnnotationHelper.simplePath'}"/></pre>
           * @param oInterface the callback interface related to the current formatter call
           * @param vRawValue the raw value from the meta model, which is embedded within an entity set or 
           * entity type:  <ul>  <li>if this function is used as formatter the value  is provided by the
           * framework</li>  <li>if this function is called directly, provide the parameter only if it is 
           * already calculated</li>  <li>if the parameter is omitted, it is calculated automatically through 
           * <code>oInterface.getObject("")</code></li>  </ul>
           * @returns the resulting string value to write into the processed XML
          */
          function simplePath(oInterface: sap.ui.core.util.XMLPreprocessor.IContext | sap.ui.model.Context, vRawValue?: any): string;
        }
        /**
         * Filter for the list binding
         * @resource sap/ui/model/odata/Filter.js
        */
        export class Filter extends sap.ui.base.Object {


          /**
           * Constructor for Filter
           * @param sPath the binding path for this filter
           * @param aValues Array of FilterOperators and their values:
           * @param bAND If true the values from aValues will be ANDed; otherwise ORed
          */
          constructor(sPath: string, aValues: any[], bAND?: boolean);



          /**
           * Converts the <code>sap.ui.model.odata.Filter</code> into a<code>sap.ui.model.Filter</code>.
           * @returns a <code>sap.ui.model.Filter</code> object
          */
          convert(): sap.ui.model.Filter;


          /**
           * Returns a metadata object for class sap.ui.model.odata.Filter.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;
        }
        /**
         * Model implementation for oData formatBinding to V4 metadata annotations is experimental!
         * @resource sap/ui/model/odata/ODataModel.js
        */
        export class ODataModel extends sap.ui.model.Model {


          /**
           * Constructor for a new ODataModel.
           * @param sServiceUrl base uri of the service to request data from; additional URL parameters appended
           * here will be appended to every request								can be passed with the mParameters object as well:
           * [mParameters.serviceUrl] A serviceURl is required!
           * @param mParameters (optional) a map which contains the following parameter properties:
          */
          constructor(sServiceUrl: string, mParameters?: any);



          /**
           * Adds (a) new URL(s) to the be parsed for OData annotations, which are then merged into the
           * annotations objectwhich can be retrieved by calling the getServiceAnnotations()-method. If a
           * $metadata url is passed the data willalso be merged into the metadata object, which can be reached
           * by calling the getServiceMetadata() method.
           * @param vUrl Either one URL as string or an array or URL strings
           * @returns The Promise to load the given URL(s), resolved if all URLs have been loaded, rejected if at
           * least one fails to load.					 If this promise resolves it returns the following parameters:					
           * annotations: The annotation object					 entitySets: An array of EntitySet objects containing the
           * newly merged EntitySets from a $metadata requests.								 the structure is the same as in the
           * metadata object reached by the getServiceMetadata() method.								 For non $metadata requests the
           * array will be empty.
          */
          addAnnotationUrl(vUrl: string | string[]): JQueryPromise<any>;

          /**
           * Adds new xml content to be parsed for OData annotations, which are then merged into the annotations
           * object whichcan be retrieved by calling the getServiceAnnotations()-method.
           * @param sXMLContent The string that should be parsed as annotation XML
           * @param bSuppressEvents Whether not to fire annotationsLoaded event on the annotationParser
           * @returns The Promise to parse the given XML-String, resolved if parsed without errors, rejected if
           * errors occur
          */
          addAnnotationXML(sXMLContent: string, bSuppressEvents?: boolean): JQueryPromise<any>;

          /**
           * Appends the change batch operations to the end of the batch stack. Only PUT, POST or DELETE batch
           * operations should be included in the specified array.The operations in the array will be included in
           * a single changeset. To embed change operations in different change sets call this method with the
           * corresponding change operations again.If an illegal batch operation is added to the change set
           * nothing will be performed and false will be returned.
           * @param aChangeOperations an array of change batch operations created via
           * <code>createBatchOperation</code> and <code>sMethod</code> = POST, PUT, MERGE or DELETE
          */
          addBatchChangeOperations(aChangeOperations: any[]): void;

          /**
           * Appends the read batch operations to the end of the batch stack. Only GET batch operations should be
           * included in the specified array.If an illegal batch operation is added to the batch nothing will be
           * performed and false will be returned.
           * @param aReadOperations an array of read batch operations created via
           * <code>createBatchOperation</code> and <code>sMethod</code> = GET
          */
          addBatchReadOperations(aReadOperations: any[]): void;

          /**
           * Attach event-handler <code>fnFunction</code> to the 'annotationsFailed' event of this
           * <code>sap.ui.model.odata.ODataModel</code>.
           * @param oData The object, that should be passed along with the event-object when firing the event.
           * @param fnFunction The function to call, when the event occurs. This function will be called on the  
           *         oListener-instance (if present) or in a 'static way'.
           * @param oListener Object on which to call the given function. If empty, the global context (window)
           * is used.
           * @returns <code>this</code> to allow method chaining
          */
          attachAnnotationsFailed(oData: any, fnFunction: any, oListener?: any): sap.ui.model.odata.ODataModel;

          /**
           * Attach event-handler <code>fnFunction</code> to the 'annotationsLoaded' event of this
           * <code>sap.ui.model.odata.ODataModel</code>.
           * @param oData The object, that should be passed along with the event-object when firing the event.
           * @param fnFunction The function to call, when the event occurs. This function will be called on the  
           *         oListener-instance (if present) or in a 'static way'.
           * @param oListener Object on which to call the given function. If empty, the global context (window)
           * is used.
           * @returns <code>this</code> to allow method chaining
          */
          attachAnnotationsLoaded(oData: any, fnFunction: any, oListener?: any): sap.ui.model.odata.ODataModel;

          /**
           * Attach event-handler <code>fnFunction</code> to the 'metadataFailed' event of this
           * <code>sap.ui.model.odata.ODataModel</code>.
           * @param oData The object, that should be passed along with the event-object when firing the event.
           * @param fnFunction The function to call, when the event occurs. This function will be called on the  
           *         oListener-instance (if present) or in a 'static way'.
           * @param oListener Object on which to call the given function. If empty, the global context (window)
           * is used.
           * @returns <code>this</code> to allow method chaining
          */
          attachMetadataFailed(oData: any, fnFunction: any, oListener?: any): sap.ui.model.odata.ODataModel;

          /**
           * Attach event-handler <code>fnFunction</code> to the 'metadataLoaded' event of this
           * <code>sap.ui.model.odata.ODataModel</code>.
           * @param oData The object, that should be passed along with the event-object when firing the event.
           * @param fnFunction The function to call, when the event occurs. This function will be called on the  
           *         oListener-instance (if present) or in a 'static way'.
           * @param oListener Object on which to call the given function. If empty, the global context (window)
           * is used.
           * @returns <code>this</code> to allow method chaining
          */
          attachMetadataLoaded(oData: any, fnFunction: any, oListener?: any): sap.ui.model.odata.ODataModel;

          /**
           * Trigger a request to the function import odata service that was specified in the model constructor.
           * @param sFunctionName A string containing the name of the function to call.		The name is concatenated
           * to the sServiceUrl which was specified in the model constructor.
           * @param mParameters Optional parameter map containing any of the following properties:
           * @returns an object which has an <code>abort</code> function to abort the current request.
          */
          callFunction(sFunctionName: string, mParameters?: any): any;

          /**
           * Removes all operations in the current batch.
          */
          clearBatch(): void;

          /**
           * Trigger a POST request to the odata service that was specified in the model constructor. Please note
           * that deep creates are not supportedand may not work.
           * @param sPath A string containing the path to the collection where an entry		should be created. The
           * path is concatenated to the sServiceUrl		which was specified in the model constructor.
           * @param oData data of the entry that should be created.
           * @param mParameters Optional parameter map containing any of the following properties:
           * @returns an object which has an <code>abort</code> function to abort the current request.
          */
          create(sPath: string, oData: any, mParameters?: any): any;

          /**
           * Creates a single batch operation (read or change operation) which can be used in a batch request.
           * @param sPath A string containing the path to the collection or entry where the batch operation
           * should be performed.						The path is concatenated to the sServiceUrl which was specified in the
           * model constructor.
           * @param sMethod for the batch operation. Possible values are GET, PUT, MERGE, POST, DELETE
           * @param oData optional data payload which should be created, updated, deleted in a change batch
           * operation.
           * @param oParameters optional parameter for additional information introduced in SAPUI5 1.9.1,
          */
          createBatchOperation(sPath: string, sMethod: string, oData?: any, oParameters?: any): void;

          /**
           * Creates a new entry object which is described by the metadata of the entity type of thespecified
           * sPath Name. A context object is returned which can be used to bindagainst the newly created
           * object.For each created entry a request is created and stored in a request queue.The request queue
           * can be submitted by calling submitChanges. To delete a createdentry from the request queue call
           * deleteCreateEntry.The optional vProperties parameter can be used as follows:  - vProperties could be
           * an array containing the property names which should be included    in the new entry. Other
           * properties defined in the entity type are not included.  - vProperties could be an object which
           * includes the desired properties and the values    which should be used for the created entry.If
           * vProperties is not specified, all properties in the entity type will be included in thecreated
           * entry.If there are no values specified the properties will have undefined values.Please note that
           * deep creates (including data defined by navigationproperties) are not supported
           * @param sPath Name of the path to the collection
           * @param vProperties An array that specifies a set of properties or the entry
           * @returns oContext A Context object that point to the new created entry.
          */
          createEntry(sPath: String, vProperties: any[] | any): sap.ui.model.Context;

          /**
           * Creates the key from the given collection name and property map
           * @param sCollection The name of the collection
           * @param oKeyParameters The object containing at least all the key properties of the entity type
           * @param bDecode Whether the URI decoding should be applied on the key
          */
          createKey(sCollection: string, oKeyParameters: any, bDecode: boolean): void;

          /**
           * Deletes a created entry from the request queue and the model.
           * @param oContext The context object pointing to the created entry
          */
          deleteCreatedEntry(oContext: sap.ui.model.Context): void;

          /**
          */
          destroy(bSuppressInvalidate: boolean): void;

          /**
           * Detach event-handler <code>fnFunction</code> from the 'annotationsFailed' event of this
           * <code>sap.ui.model.odata.ODataModel</code>.The passed function and listener object must match the
           * ones previously used for event registration.
           * @param fnFunction The function to call, when the event occurs.
           * @param oListener Object on which the given function had to be called.
           * @returns <code>this</code> to allow method chaining
          */
          detachAnnotationsFailed(fnFunction: any, oListener: any): sap.ui.model.odata.ODataModel;

          /**
           * Detach event-handler <code>fnFunction</code> from the 'annotationsLoaded' event of this
           * <code>sap.ui.model.odata.ODataModel</code>.
           * @param fnFunction The function to call, when the event occurs.
           * @param oListener Object on which the given function had to be called.
           * @returns <code>this</code> to allow method chaining
          */
          detachAnnotationsLoaded(fnFunction: any, oListener: any): sap.ui.model.odata.ODataModel;

          /**
           * Detach event-handler <code>fnFunction</code> from the 'metadataFailed' event of this
           * <code>sap.ui.model.odata.ODataModel</code>.The passed function and listener object must match the
           * ones previously used for event registration.
           * @param fnFunction The function to call, when the event occurs.
           * @param oListener Object on which the given function had to be called.
           * @returns <code>this</code> to allow method chaining
          */
          detachMetadataFailed(fnFunction: any, oListener: any): sap.ui.model.odata.ODataModel;

          /**
           * Detach event-handler <code>fnFunction</code> from the 'metadataLoaded' event of this
           * <code>sap.ui.model.odata.ODataModel</code>.The passed function and listener object must match the
           * ones previously used for event registration.
           * @param fnFunction The function to call, when the event occurs.
           * @param oListener Object on which the given function had to be called.
           * @returns <code>this</code> to allow method chaining
          */
          detachMetadataLoaded(fnFunction: any, oListener: any): sap.ui.model.odata.ODataModel;


          /**
           * Fire event annotationsFailed to attached listeners.
           * @param mArguments the arguments to pass along with the event.
           * @returns <code>this</code> to allow method chaining
          */
          fireAnnotationsFailed(mArguments: any): sap.ui.model.odata.ODataModel;

          /**
           * Fire event annotationsLoaded to attached listeners.
           * @param mArguments the arguments to pass along with the event.
           * @returns <code>this</code> to allow method chaining
          */
          fireAnnotationsLoaded(mArguments: any): sap.ui.model.odata.ODataModel;

          /**
           * Fire event metadataFailed to attached listeners.
           * @param mArguments the arguments to pass along with the event.
           * @returns <code>this</code> to allow method chaining
          */
          fireMetadataFailed(mArguments: any): sap.ui.model.odata.ODataModel;

          /**
           * Fire event metadataLoaded to attached listeners.
           * @param mArguments the arguments to pass along with the event.
           * @returns <code>this</code> to allow method chaining
          */
          fireMetadataLoaded(mArguments: any): sap.ui.model.odata.ODataModel;

          /**
           * Force no caching
           * @param bForceNoCache whether to force no caching
          */
          forceNoCache(bForceNoCache: boolean): void;

          /**
           * Return requested data as object if the data has already been loaded and stored in the model.
           * @param sPath A string containing the path to the data object that should be returned.
           * @param oContext the optional context which is used with the sPath to retrieve the requested data.
           * @param bIncludeExpandEntries This parameter should be set when a URI or custom parameterwith a
           * $expand System Query Option was used to retrieve associated entries embedded/inline.If true then the
           * getProperty function returns a desired property value/entry and includes the associated expand
           * entries (if any).If false the associated/expanded entry properties are removed and not included in
           * thedesired entry as properties at all. This is useful for performing updates on the base entry only.
           * Note: A copy and not a reference of the entry will be returned.
           * @returns oData Object containing the requested data if the path is valid.
          */
          getData(sPath: string, oContext?: any, bIncludeExpandEntries?: boolean): any;

          /**
           * Returns the default count mode for retrieving the count of collections
           * @since 1.20
          */
          getDefaultCountMode(): typeof sap.ui.model.odata.CountMode;

          /**
           * Returns all headers and custom headers which are stored in the OData model.
           * @returns the header map
          */
          getHeaders(): any;

          /**
           * Returns the key part from the entry URI or the given context or object
           * @param oObject The context or object
           * @param bDecode Whether the URI decoding should be applied on the key
          */
          getKey(oObject: any | sap.ui.model.Context, bDecode: boolean): void;

          /**
           * Returns a metadata object for class sap.ui.model.odata.ODataModel.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Returns an instance of an OData meta model which offers a unified access to both OData V2meta data
           * and V4 annotations. It uses the existing {@link sap.ui.model.odata.ODataMetadata}as a foundation and
           * merges V4 annotations from the existing{@link sap.ui.model.odata.ODataAnnotations} directly into the
           * corresponding model element.<b>BEWARE:</b> Access to this OData meta model will fail before the
           * promise returned by{@link sap.ui.model.odata.ODataMetaModel#loaded loaded} has been resolved!
           * @returns The meta model for this ODataModel
          */
          getMetaModel(): sap.ui.model.odata.ODataMetaModel;

          /**
           * Returns the value for the property with the given <code>sPath</code>.If the path points to a
           * navigation property which has been loaded via $expand then the
           * <code>bIncludeExpandEntries</code>parameter determines if the navigation property should be included
           * in the returned value or not.Please note that this currently works for 1..1 navigation properties
           * only.
           * @param sPath the path/name of the property
           * @param oContext the context if available to access the property value
           * @param bIncludeExpandEntries This parameter should be set when a URI or custom parameterwith a
           * $expand System Query Option was used to retrieve associated entries embedded/inline.If true then the
           * getProperty function returns a desired property value/entry and includes the associated expand
           * entries (if any).If false the associated/expanded entry properties are removed and not included in
           * thedesired entry as properties at all. This is useful for performing updates on the base entry only.
           * Note: A copy and not a reference of the entry will be returned.
          */
          getProperty(sPath: string, oContext?: any, bIncludeExpandEntries?: boolean): any;

          /**
           * Returns the current security token. If the token has not been requested from the server it will be
           * requested first.
           * @returns the CSRF security token
          */
          getSecurityToken(): string;

          /**
           * Return the annotation object. Please note that when using the model with bLoadMetadataAsync = true
           * then this function might return undefined because themetadata has not been loaded yet.In this case
           * attach to the <code>annotationsLoaded</code> event to get notified when the annotations are
           * available and then call this function.
           * @returns metdata object
          */
          getServiceAnnotations(): any;

          /**
           * Return the metadata object. Please note that when using the model with bLoadMetadataAsync = true
           * then this function might return undefined because themetadata has not been loaded yet.In this case
           * attach to the <code>metadataLoaded</code> event to get notified when the metadata is available and
           * then call this function.
           * @returns metdata object
          */
          getServiceMetadata(): any;

          /**
           * Checks if there exist pending changes in the model created by the setProperty method.
           * @returns true/false
          */
          hasPendingChanges(): boolean;

          /**
           * Returns whether this model supports the $count on its collectionsThis method is deprecated, please
           * use getDefaultCountMode instead.
          */
          isCountSupported(): boolean;

          /**
           * Trigger a GET request to the odata service that was specified in the model constructor.The data will
           * not be stored in the model. The requested data is returned with the response.
           * @param sPath A string containing the path to the data which should		be retrieved. The path is
           * concatenated to the sServiceUrl		which was specified in the model constructor.
           * @param mParameters Optional parameter map containing any of the following properties:
           * @returns an object which has an <code>abort</code> function to abort the current request.
          */
          read(sPath: string, mParameters?: any): any;

          /**
           * Refresh the model.This will check all bindings for updated data and update the controls if data has
           * been changed.
           * @param bForceUpdate Force update of controls
           * @param bRemoveData If set to true then the model data will be removed/cleared.					Please note that
           * the data might not be there when calling e.g. getProperty too early before the refresh call
           * returned.
          */
          refresh(bForceUpdate: boolean, bRemoveData?: boolean): void;

          /**
           * refreshes the metadata for model, e.g. in case the first request for metadata has failed
          */
          refreshMetadata(): void;

          /**
           * refresh XSRF token by performing a GET request against the service root URL.
           * @param fnSuccess a callback function which is called when the data has           					 been
           * successfully retrieved.
           * @param fnError a callback function which is called when the request failed. The handler can have the
           * parameter: oError which contains additional error information.
           * @param bAsync true for asynchronous requests.
           * @returns an object which has an <code>abort</code> function to abort the current request.
          */
          refreshSecurityToken(fnSuccess?: any, fnError?: any, bAsync?: boolean): any;

          /**
           * Trigger a DELETE request to the odata service that was specified in the model constructor.
           * @param sPath A string containing the path to the data that should be removed.		The path is
           * concatenated to the sServiceUrl which was specified in the model constructor.
           * @param mParameters Optional, can contain the following attributes: oContext, fnSuccess, fnError,
           * sETag:
           * @returns an object which has an <code>abort</code> function to abort the current request.
          */
          remove(sPath: string, mParameters?: any): any;

          /**
           * Resets the collected changes by the setProperty method and reloads the data from the server.
           * @param fnSuccess a callback function which is called when the data has           					 been
           * successfully resetted. The handler can have the           	                 following parameters:
           * oData and response.
           * @param fnError a callback function which is called when the request failed
          */
          resetChanges(fnSuccess: any, fnError?: any): void;

          /**
           * Sets whether this OData service supports $count on its collections.This method is deprecated, please
           * use setDefaultCountMode instead.
           * @param bCountSupported undefined
          */
          setCountSupported(bCountSupported: boolean): void;

          /**
           * Sets the default way to retrieve the count of collections in this model.Count can be determined
           * either by sending a separate $count request, including$inlinecount=allpages in data requests, both
           * of them or not at all.
           * @since 1.20
           * @param sCountMode undefined
          */
          setDefaultCountMode(sCountMode: typeof sap.ui.model.odata.CountMode): void;

          /**
           * Set custom headers which are provided in a key/value map. These headers are used for requests
           * against the OData backend.Private headers which are set in the ODataModel cannot be modified.These
           * private headers are: accept, accept-language, x-csrf-token, MaxDataServiceVersion,
           * DataServiceVersion.To remove these headers simply set the mCustomHeaders parameter to null. Please
           * also note that when calling this method again all previous custom headersare removed unless they are
           * specified again in the mCustomHeaders parameter.
           * @param mHeaders the header name/value map.
          */
          setHeaders(mHeaders: any): void;

          /**
           * Sets a new value for the given property <code>sPropertyName</code> in the model without triggering a
           * server request. This can be done by the submitChanges method. Note: Only one entry of one collection
           * can be updated at once. Otherwise a fireRejectChange event is fired. Before updating a different
           * entry the existing changes of the current entry have to be submitted or resetted by the
           * corresponding methods: submitChanges, resetChanges. IMPORTANT: All pending changes are resetted in
           * the model if the application triggeres any kind of refresh on that entry. Make sure to submit the
           * pending changes first. To determine if there are any pending changes call the hasPendingChanges
           * method.
           * @param sPath path of the property to set
           * @param oValue value to set the property to
           * @param oContext the context which will be used to set the property
           * @param bAsyncUpdate whether to update other bindings dependent on this property asynchronously
           * @returns true if the value was set correctly and false if errors occurred like the entry was not
           * found or another entry was already updated.
          */
          setProperty(sPath: string, oValue: any, oContext?: any, bAsyncUpdate?: boolean): boolean;

          /**
           * Enable/Disable automatic updates of all Bindings after change operations
           * @since 1.16.3
           * @param bRefreshAfterChange undefined
          */
          setRefreshAfterChange(bRefreshAfterChange: boolean): void;

          /**
           * Enable/Disable XCSRF-Token handling
           * @param bTokenHandling whether to use token handling or not
          */
          setTokenHandlingEnabled(bTokenHandling: boolean): void;

          /**
           * Enable/Disable batch for all requests
           * @param bUseBatch whether the requests should be encapsulated in a batch request
          */
          setUseBatch(bUseBatch: boolean): void;

          /**
           * Submits the collected changes in the batch which were collected via
           * <code>addBatchReadOperations</code> or <code>addBatchChangeOperations</code>.The batch will be
           * cleared afterwards. If the batch is empty no request will be performed and false will be
           * returned.Note: No data will be stored in the model.
           * @param fnSuccess a callback function which is called when the batch request has           					 been
           * successfully sent. Note: There might have errors occured in the single batch operations. These
           * errors can be accessed in the           aErrorResponses parameter in the callback handler.          
           * The handler can have the           	                 following parameters: oData, oResponse and
           * aErrorResponses.
           * @param fnError a callback function which is called when the batch request failed. The handler can
           * have the parameter: oError which containsadditional error information.
           * @param bAsync true for asynchronous request. Default is true.
           * @param bImportData undefined
           * @returns an object which has an <code>abort</code> function to abort the current request. Returns
           * false if no request will be performed because the batch is empty.
          */
          submitBatch(fnSuccess: any, fnError: any, bAsync: boolean, bImportData: boolean): any;

          /**
           * Submits the collected changes which were collected by the setProperty method. A MERGE request will
           * be triggered to only update the changed properties.If a URI with a $expand System Query Option was
           * used then the expand entries will be removed from the collected changes.Changes to this entries
           * should be done on the entry itself. So no deep updates are supported.
           * @param fnSuccess a callback function which is called when the data has           					 been
           * successfully updated. The handler can have the           	                 following parameters:
           * oData and response.
           * @param fnError a callback function which is called when the request failed. The handler can have the
           * parameter: oError which containsadditional error information
           * @param oParameters optional parameter for additional information introduced in SAPUI5 1.9.1
           * @returns an object which has an <code>abort</code> function to abort the current request.
          */
          submitChanges(fnSuccess: any, fnError?: any, oParameters?: any): any;

          /**
           * Trigger a PUT/MERGE request to the odata service that was specified in the model constructor. Please
           * note that deep updates are not supportedand may not work. These should be done seperate on the entry
           * directly.
           * @param sPath A string containing the path to the data that should be updated.		The path is
           * concatenated to the sServiceUrl which was specified		in the model constructor.
           * @param oData data of the entry that should be updated.
           * @param mParameters Optional, can contain the following attributes:
           * @returns an object which has an <code>abort</code> function to abort the current request.
          */
          update(sPath: string, oData: any, mParameters?: any): any;

          /**
           * update all bindings
           * @param bForceUpdate If set to false an update  will only be done when the value of a binding
           * changed.
          */
          updateBindings(bForceUpdate: boolean): void;
        }
        /**
         * Implementation to access oData metadata
         * @resource sap/ui/model/odata/ODataMetadata.js
        */
        export class ODataMetadata extends sap.ui.base.EventProvider {


          /**
           * Constructor for a new ODataMetadata.
           * @param sMetadataURI needs the correct metadata uri including $metadata
           * @param mParams optional map of parameters.
          */
          constructor(sMetadataURI: string, mParams?: any);



          /**
           * Attach event-handler <code>fnFunction</code> to the 'failed' event of this
           * <code>sap.ui.model.odata.ODataMetadata</code>.
           * @param oData The object, that should be passed along with the event-object when firing the event.
           * @param fnFunction The function to call, when the event occurs. This function will be called on the  
           *         oListener-instance (if present) or in a 'static way'.
           * @param oListener Object on which to call the given function. If empty, the global context (window)
           * is used.
           * @returns <code>this</code> to allow method chaining
          */
          attachFailed(oData: any, fnFunction: any, oListener?: any): sap.ui.model.odata.ODataMetadata;

          /**
           * Attach event-handler <code>fnFunction</code> to the 'loaded' event of this
           * <code>sap.ui.model.odata.ODataMetadata</code>.
           * @param oData The object, that should be passed along with the event-object when firing the event.
           * @param fnFunction The function to call, when the event occurs. This function will be called on the  
           *         oListener-instance (if present) or in a 'static way'.
           * @param oListener Object on which to call the given function. If empty, the global context (window)
           * is used.
           * @returns <code>this</code> to allow method chaining
          */
          attachLoaded(oData: any, fnFunction: any, oListener?: any): sap.ui.model.odata.ODataMetadata;

          /**
           * Detach event-handler <code>fnFunction</code> from the 'failed' event of this
           * <code>sap.ui.model.odata.ODataMetadata</code>.The passed function and listener object must match the
           * ones previously used for event registration.
           * @param fnFunction The function to call, when the event occurs.
           * @param oListener Object on which the given function had to be called.
           * @returns <code>this</code> to allow method chaining
          */
          detachFailed(fnFunction: any, oListener: any): sap.ui.model.odata.ODataMetadata;

          /**
           * Detach event-handler <code>fnFunction</code> from the 'loaded' event of this
           * <code>sap.ui.model.odata.ODataMetadata</code>.The passed function and listener object must match the
           * ones previously used for event registration.
           * @param fnFunction The function to call, when the event occurs.
           * @param oListener Object on which the given function had to be called.
           * @returns <code>this</code> to allow method chaining
          */
          detachLoaded(fnFunction: any, oListener: any): sap.ui.model.odata.ODataMetadata;


          /**
           * Fire event failed to attached listeners.
           * @param mArguments the arguments to pass along with the event.
           * @returns <code>this</code> to allow method chaining
          */
          fireFailed(mArguments: any): sap.ui.model.odata.ODataMetadata;

          /**
           * Fire event loaded to attached listeners.
           * @returns <code>this</code> to allow method chaining
          */
          fireLoaded(): sap.ui.model.odata.ODataMetadata;

          /**
           * Returns a metadata object for class sap.ui.model.odata.ODataMetadata.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Return the metadata object
           * @returns metdata object
          */
          getServiceMetadata(): any;

          /**
           * Get the the use-batch extension value if any
           * @returns true/false
          */
          getUseBatch(): boolean;

          /**
           * Checks whether metadata loading has already failed
           * @returns returns whether metadata request has failed
          */
          isFailed(): boolean;

          /**
           * Checks whether metadata is available
           * @returns returns whether metadata is already loaded
          */
          isLoaded(): boolean;

          /**
           * Returns a promise for the loaded state of the metadata
           * @returns returns a promise on metadata loaded state
          */
          loaded(): JQueryPromise<any>;

          /**
           * Refreshes the metadata creating a new request to the server.Returns a new promise which can be
           * resolved or rejected depending on the metadata loading state.
           * @returns returns a promise on metadata loaded state
          */
          refresh(): JQueryPromise<any>;
        }
        /**
         * Implementation of an OData meta model which offers a unified access to both OData V2meta data and V4
         * annotations. It uses the existing {@link sap.ui.model.odata.ODataMetadata}as a foundation and merges
         * V4 annotations from the existing{@link sap.ui.model.odata.ODataAnnotations} directly into the
         * corresponding model element.Also, annotations from the "http://www.sap.com/Protocols/SAPData"
         * namespace are lifted upfrom the <code>extensions</code> array and transformed from objects into
         * simple propertieswith an "sap:" prefix for their name. Note that this happens in addition, thus
         * thefollowing example shows both representations. This way, such annotations can be addressedvia a
         * simple relative path instead of searching an array.<pre>		{			"name" : "BusinessPartnerID",		
         * "extensions" : [{				"name" : "label",				"value" : "Bus. Part. ID",				"namespace" :
         * "http://www.sap.com/Protocols/SAPData"			}],			"sap:label" : "Bus. Part. ID"		}</pre>As of 1.29.0,
         * the corresponding vocabulary-based annotations for the following"<a
         * href="http://www.sap.com/Protocols/SAPData">SAP Annotations for OData Version 2.0</a>"are added, if
         * they are not yet defined in the V4
         * annotations:<ul><li><code>label</code>;</li><li><code>creatable</code>, <code>deletable</code>,
         * <code>deletable-path</code>,<code>pageable</code>, <code>requires-filter</code>,
         * <code>searchable</code>,<code>topable</code>, <code>updatable</code> and <code>updatable-path</code>
         * on entity sets;</li><li><code>creatable</code>, <code>display-format</code> ("UpperCase" and
         * "NonNegative"),<code>field-control</code>, <code>filterable</code>,
         * <code>filter-restriction</code>,<code>heading</code>, <code>precision</code>,
         * <code>quickinfo</code>,<code>required-in-filter</code>, <code>sortable</code>, <code>text</code>,
         * <code>unit</code>,<code>updatable</code> and <code>visible</code> on
         * properties;</li><li><code>semantics</code>; the following values are supported:<ul><li>"bday",
         * "city", "country", "email" (including support for types, for example"email;type=home,pref"),
         * "familyname", "givenname", "honorific", "middlename", "name","nickname", "note", "org", "org-unit",
         * "org-role", "photo", "pobox", "region", "street","suffix", "tel" (including support for types, for
         * example "tel;type=cell,pref"), "title" and"zip" (mapped to V4 annotation
         * <code>com.sap.vocabularies.Communication.v1.Contact</code>);</li><li>"class", "dtend", "dtstart",
         * "duration", "fbtype", "location", "status", "transp" and"wholeday" (mapped to V4
         * annotation<code>com.sap.vocabularies.Communication.v1.Event</code>);</li><li>"body", "from",
         * "received", "sender" and "subject" (mapped to V4
         * annotation<code>com.sap.vocabularies.Communication.v1.Message</code>);</li><li>"completed", "due",
         * "percent-complete" and "priority" (mapped to V4
         * annotation<code>com.sap.vocabularies.Communication.v1.Task</code>).</li></ul></ul>For example:<pre>	
         * {			"name" : "BusinessPartnerID",			...			"sap:label" : "Bus. Part. ID",		
         * "com.sap.vocabularies.Common.v1.Label" : {				"String" : "Bus. Part. ID"			}		}</pre>This model is
         * read-only and thus only supports{@link sap.ui.model.BindingMode.OneTime OneTime} binding mode. No
         * events({@link sap.ui.model.Model#event:parseError parseError},{@link
         * sap.ui.model.Model#event:requestCompleted requestCompleted},{@link
         * sap.ui.model.Model#event:requestFailed requestFailed},{@link sap.ui.model.Model#event:requestSent
         * requestSent}) are fired!Within the meta model, the objects are arranged in
         * arrays.<code>/dataServices/schema</code>, for example, is an array of schemas where each schema
         * hasan <code>entityType</code> property with an array of entity types, and so on.
         * So,<code>/dataServices/schema/0/entityType/16</code> can be the path to the entity type withname
         * "Order" in the schema with namespace "MySchema". However, these paths are not stable:If an entity
         * type with lower index is removed from the schema, the path to<code>Order</code> changes to
         * <code>/dataServices/schema/0/entityType/15</code>.To avoid problems with changing indexes, {@link
         * sap.ui.model.Model#getObject getObject} and{@link sap.ui.model.Model#getProperty getProperty}
         * support XPath-like queries for theindexes (since 1.29.1). Each index can be replaced by a query in
         * square brackets. You can,for example, address the schema using the
         * path<code>/dataServices/schema/[${namespace}==='MySchema']</code> or the entity
         * <code>/dataServices/schema/[${namespace}==='MySchema']/entityType/[sap.ui.core==='Order']</code>.The
         * syntax inside the square brackets is the same as in expression binding. The query isexecuted for
         * each object in the array until the result is true (truthy) for the first time.This object is then
         * chosen.<b>BEWARE:</b> Access to this OData meta model will fail before the promise returned by{@link
         * #loaded loaded} has been resolved!
         * @resource sap/ui/model/odata/ODataMetaModel.js
        */
        export class ODataMetaModel extends sap.ui.model.MetaModel {


          /**
           * DO NOT CALL this private constructor for a new <code>ODataMetaModel</code>,but rather use {@link
           * sap.ui.model.odata.ODataModel#getMetaModel getMetaModel} instead!
           * @param oMetadata the OData model's meta data object
           * @param oAnnotations the OData model's annotations object
           * @param oODataModelInterface the private interface object of the OData model which provides friend
           * access to  selected methods
          */
          constructor(oMetadata: sap.ui.model.odata.ODataMetadata, oAnnotations?: sap.ui.model.odata.ODataAnnotations, oODataModelInterface?: any);




          /**
           * Returns the OData meta model context corresponding to the given OData model path.
           * @param sPath an absolute path pointing to an entity or property, e.g. 
           * "/ProductSet(1)/ToSupplier/BusinessPartnerID"; this equals the  <a
           * href="http://www.odata.org/documentation/odata-version-2-0/uri-conventions#ResourcePath">  resource
           * path</a> component of a URI according to OData V2 URI conventions
           * @returns the context for the corresponding meta data object, i.e. an entity type or its property, 
           * or <code>null</code> in case no path is given
          */
          getMetaContext(sPath: string): sap.ui.model.Context;

          /**
           * Returns a metadata object for class sap.ui.model.odata.ODataMetaModel.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Returns the OData association end corresponding to the given entity type's navigationproperty of
           * given name.
           * @param oEntityType an entity type as returned by {@link #getODataEntityType getODataEntityType}
           * @param sName the name of a navigation property within this entity type
           * @returns the OData association end or <code>null</code> if no such association end is found
          */
          getODataAssociationEnd(oEntityType: any, sName: string): any;

          /**
           * Returns the OData association <em>set</em> end corresponding to the given entity type'snavigation
           * property of given name.
           * @param oEntityType an entity type as returned by {@link #getODataEntityType getODataEntityType}
           * @param sName the name of a navigation property within this entity type
           * @returns the OData association set end or <code>null</code> if no such association set end is found
          */
          getODataAssociationSetEnd(oEntityType: any, sName: string): any;

          /**
           * Returns the OData complex type with the given qualified name, either as a path or as anobject, as
           * indicated.
           * @param sQualifiedName a qualified name, e.g. "ACME.Address"
           * @param bAsPath determines whether the complex type is returned as a path or as an object
           * @returns (the path to) the complex type with the given qualified name; <code>undefined</code> (for 
           * a path) or <code>null</code> (for an object) if no such type is found
          */
          getODataComplexType(sQualifiedName: string, bAsPath?: boolean): any | string;

          /**
           * Returns the OData default entity container.
           * @param bAsPath determines whether the entity container is returned as a path or as an object
           * @returns (the path to) the default entity container; <code>undefined</code> (for a path) or 
           * <code>null</code> (for an object) if no such container is found
          */
          getODataEntityContainer(bAsPath: boolean): any | string;

          /**
           * Returns the OData entity set with the given simple name from the default entity container.
           * @param sName a simple name, e.g. "ProductSet"
           * @param bAsPath determines whether the entity set is returned as a path or as an object
           * @returns (the path to) the entity set with the given simple name; <code>undefined</code> (for a 
           * path) or <code>null</code> (for an object) if no such set is found
          */
          getODataEntitySet(sName: string, bAsPath?: boolean): any | string;

          /**
           * Returns the OData entity type with the given qualified name, either as a path or as anobject, as
           * indicated.
           * @param sQualifiedName a qualified name, e.g. "ACME.Product"
           * @param bAsPath determines whether the entity type is returned as a path or as an object
           * @returns (the path to) the entity type with the given qualified name; <code>undefined</code> (for a 
           * path) or <code>null</code> (for an object) if no such type is found
          */
          getODataEntityType(sQualifiedName: string, bAsPath?: boolean): any | string;

          /**
           * Returns the OData function import with the given simple or qualified name from the defaultentity
           * container or the respective entity container specified in the qualified name.
           * @since 1.29.0
           * @param sName a simple or qualified name, e.g. "Save" or "MyService.Entities/Save"
           * @param bAsPath determines whether the function import is returned as a path or as an object
           * @returns (the path to) the function import with the given simple name; <code>undefined</code> (for 
           * a path) or <code>null</code> (for an object) if no such function import is found
          */
          getODataFunctionImport(sName: string, bAsPath?: boolean): any | string;

          /**
           * Returns the given OData type's property (not navigation property!) of given name.If an array is
           * given instead of a single name, it is consumed (via<code>Array.prototype.shift</code>) piece by
           * piece. Each element is interpreted as aproperty name of the current type, and the current type is
           * replaced by that property's type.This is repeated until an element is encountered which cannot be
           * resolved as a property nameof the current type anymore; in this case, the last property found is
           * returned and<code>vName</code> contains only the remaining names, with <code>vName[0]</code> being
           * theone which was not found.Examples:<ul><li> Get address property of business partner:<pre>var
           * oEntityType = oMetaModel.getODataEntityType("GWSAMPLE_BASIC.BusinessPartner"),    oAddressProperty =
           * oMetaModel.getODataProperty(oEntityType, "Address");oAddressProperty.name ===
           * "Address";oAddressProperty.type === "GWSAMPLE_BASIC.CT_Address";</pre></li><li> Get street property
           * of address type:<pre>var oComplexType = oMetaModel.getODataComplexType("GWSAMPLE_BASIC.CT_Address"),
           *    oStreetProperty = oMetaModel.getODataProperty(oComplexType, "Street");oStreetProperty.name ===
           * "Street";oStreetProperty.type === "Edm.String";</pre></li><li> Get address' street property directly
           * from business partner:<pre>var aParts = ["Address",
           * "Street"];oMetaModel.getODataProperty(oEntityType, aParts) === oStreetProperty;aParts.length ===
           * 0;</pre></li><li> Trying to get address' foo property directly from business partner:<pre>aParts =
           * ["Address", "foo"];oMetaModel.getODataProperty(oEntityType, aParts) ===
           * oAddressProperty;aParts.length === 1;aParts[0] === "foo";</pre></li></ul>
           * @param oType a complex type as returned by {@link #getODataComplexType getODataComplexType}, or  an
           * entity type as returned by {@link #getODataEntityType getODataEntityType}
           * @param vName the name of a property within this type (e.g. "Address"), or an array of such names
           * (e.g.  <code>["Address", "Street"]</code>) in order to drill-down into complex types;  <b>BEWARE</b>
           * that this array is modified by removing each part which is understood!
           * @param bAsPath determines whether the property is returned as a path or as an object
           * @returns (the path to) the last OData property found; <code>undefined</code> (for a path) or 
           * <code>null</code> (for an object) if no property was found at all
          */
          getODataProperty(oType: any, vName: string | string[], bAsPath?: boolean): any | string;

          /**
           * Returns a <code>Promise</code> which is resolved with a map representing
           * the<code>com.sap.vocabularies.Common.v1.ValueList</code> annotations of the given property
           * orrejected with an error.The key in the map provided on successful resolution is the qualifier of
           * the annotation orthe empty string if no qualifier is defined. The value in the map is the JSON
           * object forthe annotation. The map is empty if the property has
           * no<code>com.sap.vocabularies.Common.v1.ValueList</code> annotations.
           * @since 1.29.1
           * @param oPropertyContext a model context for a structural property of an entity type or a complex
           * type, as  returned by {@link #getMetaContext getMetaContext}
           * @returns a Promise that gets resolved as soon as the value lists as well as the required model 
           * elements have been loaded
          */
          getODataValueLists(oPropertyContext: sap.ui.model.Context): JQueryPromise<any>;

          /**
           * Returns a promise which is fulfilled once the meta model data is loaded and can be used.
           * @returns a Promise
          */
          loaded(): JQueryPromise<any>;

          /**
           * Refresh not supported by OData meta model!
          */
          refresh(): void;

          /**
           * Legacy syntax not supported by OData meta model!
           * @param bLegacySyntax must not be true!
          */
          setLegacySyntax(bLegacySyntax: boolean): void;
        }
        /**
         * List binding implementation for oData format
         * @resource sap/ui/model/odata/ODataListBinding.js
        */
        export class ODataListBinding extends sap.ui.model.ListBinding {


          constructor(oModel: sap.ui.model.Model, sPath: string, oContext: sap.ui.model.Context, aSorters?: any[], aFilters?: any[], mParameters?: any);




          /**
           * Filters the list.When using sap.ui.model.Filter the filters are first grouped according to their
           * binding path.All filters belonging to a group are combined with OR and after that theresults of all
           * groups are combined with AND.Usually this means, all filters applied to a single table columnare
           * combined with OR, while filters on different table columns are combined with AND.Please note that a
           * custom filter function is not supported.
           * @param aFilters Array of filter objects
           * @param sFilterType Type of the filter which should be adjusted, if it is not given, the standard
           * behaviour applies
           * @returns returns <code>this</code> to facilitate method chaining
          */
          filter(aFilters: sap.ui.model.Filter[] | sap.ui.model.odata.Filter[], sFilterType: typeof sap.ui.model.FilterType): sap.ui.model.ListBinding;

          /**
           * Return contexts for the list
           * @param iStartIndex the start index of the requested contexts
           * @param iLength the requested amount of contexts
           * @param iThreshold undefined
           * @returns the array of contexts for each row of the bound list
          */
          getContexts(iStartIndex: number, iLength?: number, iThreshold?: number): sap.ui.model.Context[];

          /**
           * Get a download URL with the specified format considering thesort/filter/custom parameters.
           * @since 1.24
           * @param sFormat Value for the $format Parameter
           * @returns URL which can be used for downloading
          */
          getDownloadUrl(sFormat: string): string;

          /**
           * Returns a metadata object for class sap.ui.model.odata.ODataListBinding.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Initialize binding. Fires a change if data is already available ($expand) or a refresh.If metadata
           * is not yet available, do nothing, method will be called again whenmetadata is loaded.
          */
          initialize(): void;

          /**
           * Refreshes the binding, check whether the model data has been changed and fire change eventif this is
           * the case. For server side models this should refetch the data from the server.To update a control,
           * even if no data has been changed, e.g. to reset a control after failedvalidation, please use the
           * parameter bForceUpdate.
           * @param bForceUpdate Update the bound control even if no data has been changed
          */
          refresh(sGroupIdOrForceUpdate: string | boolean): void;

          /**
           * Sorts the list.
           * @param aSorters the Sorter or an array of sorter objects object which define the sort order
           * @returns returns <code>this</code> to facilitate method chaining
          */
          sort(aSorters: sap.ui.model.Sorter[] | sap.ui.model.Sorter): sap.ui.model.ListBinding | void;
        }
        /**
         * Implementation to access oData Annotations
         * @resource sap/ui/model/odata/ODataAnnotations.js
        */
        export class ODataAnnotations extends sap.ui.base.EventProvider {


          constructor(aAnnotationURI: string | string[], oMetadata: sap.ui.model.odata.ODataMetadata, mParams: any);



          /**
           * Adds either one URL or an array of URLs to be loaded and parsed. The result will be merged into the
           * annotationsdata which can be retrieved using the getAnnotations-method.
           * @param vUrl Either one URL as string or an array of URL strings
           * @returns The Promise to load the given URL(s), resolved if all URLs have been loaded, rejected if at
           *        least one failed to load. The argument is an object containing the annotations object,
           * success (an array        of sucessfully loaded URLs), fail (an array ob of failed URLs).
          */
          addUrl(vUrl: string | string[]): JQueryPromise<any>;

          /**
           * Attach event-handler <code>fnFunction</code> to the 'failed' event of this
           * <code>sap.ui.model.odata.ODataAnnotations</code>.
           * @param oData The object, that should be passed along with the event-object when firing the event.
           * @param fnFunction The function to call, when the event occurs. This function will be called on the  
           *         oListener-instance (if present) or in a 'static way'.
           * @param oListener Object on which to call the given function. If empty, the global context (window)
           * is used.
           * @returns <code>this</code> to allow method chaining
          */
          attachFailed(oData: any, fnFunction: any, oListener?: any): sap.ui.model.odata.ODataAnnotations;

          /**
           * Attach event-handler <code>fnFunction</code> to the 'loaded' event of this
           * <code>sap.ui.model.odata.ODataAnnotations</code>.
           * @param oData The object, that should be passed along with the event-object when firing the event.
           * @param fnFunction The function to call, when the event occurs. This function will be called on the  
           *         oListener-instance (if present) or in a 'static way'.
           * @param oListener Object on which to call the given function. If empty, the global context (window)
           * is used.
           * @returns <code>this</code> to allow method chaining
          */
          attachLoaded(oData: any, fnFunction: any, oListener?: any): sap.ui.model.odata.ODataAnnotations;

          /**
           * Detach event-handler <code>fnFunction</code> from the 'failed' event of this
           * <code>sap.ui.model.odata.ODataAnnotations</code>.The passed function and listener object must match
           * the ones previously used for event registration.
           * @param fnFunction The function to call, when the event occurs.
           * @param oListener Object on which the given function had to be called.
           * @returns <code>this</code> to allow method chaining
          */
          detachFailed(fnFunction: any, oListener: any): sap.ui.model.odata.ODataAnnotations;

          /**
           * Detach event-handler <code>fnFunction</code> from the 'loaded' event of this
           * <code>sap.ui.model.odata.ODataAnnotations</code>.The passed function and listener object must match
           * the ones previously used for event registration.
           * @param fnFunction The function to call, when the event occurs.
           * @param oListener Object on which the given function had to be called.
           * @returns <code>this</code> to allow method chaining
          */
          detachLoaded(fnFunction: any, oListener: any): sap.ui.model.odata.ODataAnnotations;


          /**
           * Fire event failed to attached listeners.
           * @param mArguments the arguments to pass along with the event.
           * @returns <code>this</code> to allow method chaining
          */
          fireFailed(mArguments: any): sap.ui.model.odata.ODataAnnotations;

          /**
           * Fire event loaded to attached listeners.
           * @param mArguments Map of arguments that will be given as parameters to teh event handler
           * @returns <code>this</code> to allow method chaining
          */
          fireLoaded(mArguments: any): sap.ui.model.odata.ODataAnnotations;

          /**
           * returns the raw annotation data
           * @returns returns annotations data
          */
          getAnnotationsData(): any;

          /**
           * Returns a metadata object for class sap.ui.model.odata.ODataAnnotations.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Checks whether annotations loading of at least one of the given URLs has already failed.Note: For
           * asynchronous annotations {@link #attachFailed} has to be used.
           * @returns whether annotations request has failed
          */
          isFailed(): boolean;

          /**
           * Checks whether annotations from at least one source are available
           * @returns returns whether annotations is already loaded
          */
          isLoaded(): boolean;

          /**
           * Set custom headers which are provided in a key/value map. These headers are used for all
           * requests.The Accept-Language header cannot be modified and is set using the Core's language
           * setting.To remove these headers simply set the mHeaders parameter to {}. Please also note that when
           * calling this methodagain all previous custom headers are removed unless they are specified again in
           * the mCustomHeaders parameter.
           * @param mHeaders the header name/value map.
          */
          setHeaders(mHeaders: any): void;

          /**
           * Sets an XML document
           * @param oXMLDocument The XML document to parse for annotations
           * @param sXMLContent The XML content as string to parse for annotations
           * @param mOptions Additional options
           * @returns Whether or not parsing was successful
          */
          setXML(oXMLDocument: any, sXMLContent: string, mOptions?: any): boolean;
        }
        /**
         * OData implementation of the sap.ui.core.message.MessageParser class. Parses message responses from
         * the back-end.
         * @resource sap/ui/model/odata/ODataMessageParser.js
        */
        export abstract class ODataMessageParser extends sap.ui.core.message.MessageParser {


          /**
           * OData implementation of the sap.ui.core.message.MessageParser class. Parses message responses from
           * the back-end.
          */
          constructor();




          /**
           * Returns the name of the header field that is used to parse the server messages
           * @returns The name of the header field
          */
          getHeaderField(): string;

          /**
           * Returns a metadata object for class sap.ui.model.odata.ODataMessageParser.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Parses the given response for messages, calculates the delta and fires the messageChange-eventon the
           * MessageProcessor if messages are found.
           * @param oResponse The response from the server containing body and headers
           * @param oRequest The original request that lead to this response
           * @param mGetEntities A map containing the entities requested from the back-end as keys
           * @param mChangeEntities A map containing the entities changed on the back-end as keys
          */
          parse(oResponse?: any, oRequest?: any, mGetEntities?: any, mChangeEntities?: any): void;

          /**
           * Sets the header field name that should be used for parsing the JSON messages
           * @param sFieldName The name of the header field that should be used as source of the message object
           * @returns Instance reference for method chaining
          */
          setHeaderField(sFieldName: string): sap.ui.model.odata.ODataMessageParser;
        }
        /**
         * The ContextBinding is a specific binding for a setting context for the model
         * @resource sap/ui/model/odata/ODataContextBinding.js
        */
        export abstract class ODataContextBinding extends sap.ui.model.ContextBinding {


          /**
           * Constructor for odata.ODataContextBinding
           * @param oModel undefined
           * @param sPath undefined
           * @param oContext undefined
           * @param mParameters undefined
          */
          constructor(oModel: sap.ui.model.Model, sPath: String, oContext: any, mParameters?: any);




          /**
           * Returns a metadata object for class sap.ui.model.odata.ODataContextBinding.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;
        }
        /**
         * Property binding implementation for oData format
         * @resource sap/ui/model/odata/ODataPropertyBinding.js
        */
        export class ODataPropertyBinding extends sap.ui.model.PropertyBinding {


          constructor(oModel: sap.ui.model.Model, sPath: string, oContext: sap.ui.model.Context, mParameters?: any);




          /**
           * Returns a metadata object for class sap.ui.model.odata.ODataPropertyBinding.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Returns the current value of the bound target
           * @returns the current value of the bound target
          */
          getValue(): any;

          /**
           * Initialize the binding. The message should be called when creating a binding.If metadata is not yet
           * available, do nothing, method will be called again whenmetadata is loaded.
          */
          initialize(): void;
        }
      }
      namespace message {
        /**
         * Model implementation for Messages	 *
         * @resource sap/ui/model/message/MessageModel.js
        */
        export class MessageModel extends sap.ui.model.ClientModel {


          /**
           * Constructor for a new JSONModel.
           * @param oMessageManager The MessageManager instance
          */
          constructor(oMessageManager: sap.ui.core.message.MessageManager);




          /**
           * Returns a metadata object for class sap.ui.model.message.MessageModel.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Returns the value for the property with the given <code>sPropertyName</code>
           * @param sPath the path to the property
           * @param oContext the context which will be used to retrieve the property
          */
          getProperty(sPath: string, oContext?: any): any;

          /**
           * Sets the message data to the model.
           * @param oData the data to set on the model
          */
          setData(oData: any): void;

          /**
           * Sets a new value for the given property <code>sPropertyName</code> in the model.If the model value
           * changed all interested parties are informed.
           * @param sPath path of the property to set
           * @param oValue value to set the property to
           * @param oContext the context which will be used to set the property
          */
          setProperty(sPath: string, oValue: any, oContext?: any): void;
        }
      }
      namespace control {
      }
      namespace resource {
        /**
         * Model implementation for resource bundles
         * @resource sap/ui/model/resource/ResourceModel.js
        */
        export class ResourceModel extends sap.ui.model.Model {


          /**
           * Constructor for a new ResourceModel.
           * @param oData parameters used to initialize the ResourceModel; at least either bundleUrl or
           * bundleName must be set on this object; if both are set, bundleName wins
          */
          constructor(oData: any);



          /**
           * Enhances the resource model with a custom resource bundle. The resource modelcan be enhanced with
           * multiple resource bundles. The last enhanced resourcebundle wins against the previous ones and the
           * original ones. This functioncan be called several times.
           * @since 1.16.1
           * @param oData parameters used to initialize the ResourceModel; at least either bundleUrl or
           * bundleName must be set on this object; if both are set, bundleName wins - or an instance of an
           * existing {@link jQuery.sap.util.ResourceBundle}
           * @returns Promise in async case (async ResourceModel) which is resolved when the the enhancement is
           * finished
          */
          enhance(oData: any | any): JQueryPromise<any>;


          /**
           * Returns a metadata object for class sap.ui.model.resource.ResourceModel.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Returns the value for the property with the given <code>sPropertyName</code>
           * @param sPath the path to the property
          */
          getProperty(sPath: string): any;

          /**
           * Returns the resource bundle of this model
           * @returns loaded resource bundle or ECMA Script 6 Promise in asynchronous case
          */
          getResourceBundle(): any | JQueryPromise<any>;
        }
      }
      namespace analytics {

        /**
         * If called on an instance of an (v1/v2) ODataModel it will enrich it with analytics capabilities.
        */
        function ODataModelAdapter(): void;
        namespace odata4analytics {

          /**
           * Specify which components of the dimension shall be included in the valueset.
           * @param bIncludeText Indicator whether or not to include the dimension text (if           available)
           * in the value set.
           * @param bIncludeAttributes Indicator whether or not to include all dimension attributes           (if
           * available) in the value set.
          */
          function includeDimensionTextAttributes(bIncludeText: any, bIncludeAttributes: any): void;
          namespace Model {
            /**
             * Handle to an OData model by the URI pointing to it.
             * @resource sap/ui/model/analytics/odata4analytics.js
            */
            export class ReferenceByURI {


              /**
               * Create a reference to an OData model by the URI of the related OData service.
               * @param sURI holding the URI.
              */
              constructor(sURI: string);


            }
            /**
             * Handle to an already instantiated SAP UI5 OData model.
             * @resource sap/ui/model/analytics/odata4analytics.js
            */
            export class ReferenceByModel {


              /**
               * Create a reference to an OData model already loaded elsewhere with the helpof SAP UI5.
               * @param oModel holding the OData model.
              */
              constructor(oModel: any);


            }
            /**
             * Handle to an already instantiated SAP UI5 OData model.
             * @resource sap/ui/model/analytics/odata4analytics.js
            */
            export class ReferenceWithWorkaround {


              /**
               * Create a reference to an OData model having certain workarounds activated. Aworkaround is an
               * implementation that changes the standard behavior of the APIto overcome some gap or limitation in
               * the OData provider. The workaroundimplementation can be conditionally activated by passing the
               * identifier inthe contructor.Known workaround identifiers are:<li>"CreateLabelsFromTechnicalNames" -
               * If a property has no label text, itgets generated from the property
               * name.</li><li>"IdentifyTextPropertiesByName" -If a dimension property has no text andanother
               * property with the same name and an appended "Name", "Text" etc.exists, they are linked via
               * annotation.</li>
               * @param oModel holding a reference to the OData model, obtained           by
               * odata4analytics.Model.ReferenceByModel or by           sap.odata4analytics.Model.ReferenceByURI.
               * @param aWorkaroundID listing all workarounds to be applied.
              */
              constructor(oModel: any, aWorkaroundID: string[]);


            }
          }
          namespace SortOrder {
          }
          /**
           * Representation of an OData model with analytical annotations defined       by OData4SAP.
           * @resource sap/ui/model/analytics/odata4analytics.js
          */
          export class Model {


            /**
             * Create a representation of the analytical semantics of OData service metadata
             * @param oModelReference An instance of ReferenceByURI, ReferenceByModel or          
             * ReferenceWithWorkaround for locating the OData service.
             * @param mParameter Additional parameters for controlling the model construction. Currently supported
             * are:           <li> sAnnotationJSONDoc - A JSON document providing extra annotations to the elements
             * of the                structure of the given service           </li>           <li> modelVersion -
             * Parameter to define which ODataModel version should be used, in you use               
             * 'odata4analytics.Model.ReferenceByURI': 1 (default), 2                see also:
             * AnalyticalVersionInfo constants           </li>
            */
            constructor(oModelReference: any, mParameter?: any);



            /**
             * Find analytic query result by name
             * @param sName Fully qualified name of query result entity set
             * @returns The query result object         with this name or null if it does not exist
            */
            findQueryResultByName(sName: string): sap.ui.model.analytics.odata4analytics.QueryResult;

            /**
             * Get the names of all query results (entity sets) offered by the model
             * @returns List of all query result names
            */
            getAllQueryResultNames(): string[];

            /**
             * Get all query results offered by the model
             * @returns An object with individual JS properties for each query         result included in the
             * model. The JS object properties all are         objects of type odata4analytics.QueryResult. The
             * names         of the JS object properties are given by the entity set names         representing the
             * query results.
            */
            getAllQueryResults(): any;

            /**
             * Get underlying OData model provided by SAP UI5
             * @returns The SAP UI5 representation of the model.
            */
            getODataModel(): any;
          }
          /**
           * Representation of a property annotated with       sap:aggregation-role="measure".
           * @resource sap/ui/model/analytics/odata4analytics.js
          */
          export class Measure {


            /**
             * Create a representation of a measure provided by an analytic query. Do not create your own
             * instances.
             * @param oQueryResult The query result containing this measure
             * @param oProperty The DataJS object object representing the measure
            */
            constructor(oQueryResult: sap.ui.model.analytics.odata4analytics.QueryResult, oProperty: any);



            /**
             * Get the text property associated to the raw value property holding theformatted value related to
             * this measure
             * @returns The DataJS object representing the property holding the         formatted value text of
             * this measure or null if this measure         does not have a unit
            */
            getFormattedValueProperty(): any;

            /**
             * Get label
             * @returns The (possibly language-dependent) label text for this         measure
            */
            getLabelText(): string;

            /**
             * Get the name of the measure
             * @returns The name of the measure, which is identical to the name         of the measure raw value
             * property in the entity type
            */
            getName(): string;

            /**
             * Get the raw value property
             * @returns The DataJS object representing the property holding the         raw value of this measure
            */
            getRawValueProperty(): any;

            /**
             * Get the unit property related to this measure
             * @returns The DataJS object representing the unit property or         null if this measure does not
             * have a unit
            */
            getUnitProperty(): any;

            /**
             * Get indicator whether or not the measure is updatable
             * @returns True iff the measure is updatable
            */
            isUpdatable(): boolean;
          }
          /**
           * Representation of a property annotated with sap:parameter.
           * @resource sap/ui/model/analytics/odata4analytics.js
          */
          export class Parameter {


            /**
             * Create a representation of a single parameter contained in a parameterization. Do not create your
             * own instances.
             * @param oParameterization The parameterization containing this parameter
             * @param oProperty The DataJS object object representing the text property
            */
            constructor(oParameterization: sap.ui.model.analytics.odata4analytics.Parameterization, oProperty: any);



            /**
             * Get parameterization containing this parameter
             * @returns The parameterization        object
            */
            getContainingParameterization(): sap.ui.model.analytics.odata4analytics.Parameterization;

            /**
             * Get label
             * @returns The (possibly language-dependent) label text for this         parameter
            */
            getLabelText(): string;

            /**
             * Get the name of the parameter
             * @returns The name of the parameter, which is identical with the         name of the property
             * representing the parameter in the         parameterization entity type
            */
            getName(): string;

            /**
             * Get property for the parameter representing the peer boundary of the sameinterval
             * @returns The parameter representing         the peer boundary of the same interval. This means that
             * if         *this* parameter is a lower boundary, the returned object
            */
            getPeerIntervalBoundaryParameter(): sap.ui.model.analytics.odata4analytics.Parameter;

            /**
             * Get property
            */
            getProperty(): any;

            /**
             * Get text property related to this parameter
             * @returns The DataJS object representing the text property or         null if it does not exist
            */
            getTextProperty(): any;

            /**
             * Get the URI to locate the entity set holding the value set, if it isavailable.
             * @param sServiceRootURI (optional) Identifies the root of the OData           service
            */
            getURIToValueEntitySet(sServiceRootURI: String): void;

            /**
             * Get indicator if the parameter represents an interval boundary
             * @returns True iff it represents an interval boundary, otherwise         false
            */
            isIntervalBoundary(): boolean;

            /**
             * Get indicator if the parameter represents the lower boundary of aninterval
             * @returns True iff it represents the lower boundary of an         interval, otherwise false
            */
            isLowerIntervalBoundary(): boolean;

            /**
             * Get indicator whether or not the parameter is optional
             * @returns True iff the parameter is optional
            */
            isOptional(): boolean;

            /**
             * Get indicator if a set of values is available for this parameter.Typically, this is true for
             * parameters with a finite set of known valuessuch as products, business partners in different roles,
             * organizationunits, and false for integer or date parameters
             * @returns True iff a value set is available, otherwise false
            */
            isValueSetAvailable(): boolean;
          }
          /**
           * Representation of a property annotated with       sap:aggregation-role="dimension".
           * @resource sap/ui/model/analytics/odata4analytics.js
          */
          export class Dimension {


            /**
             * Create a representation of a dimension provided by an analytic query. Do not create your own
             * instances.
             * @param oQueryResult The query result containing this dimension
             * @param oProperty The DataJS object object representing the dimension
            */
            constructor(oQueryResult: sap.ui.model.analytics.odata4analytics.QueryResult, oProperty: any);



            /**
             * Find attribute by name
             * @param sName Attribute name
             * @returns The dimension attribute         object with this name or null if it does not exist
            */
            findAttributeByName(sName: string): sap.ui.model.analytics.odata4analytics.Dimension;

            /**
             * Get the names of all attributes included in this dimension
             * @returns List of all attribute names
            */
            getAllAttributeNames(): string[];

            /**
             * Get all attributes of this dimension
             * @returns An object with individual JS properties for each         attribute of this dimension. The
             * JS object properties all are         objects of type odata4analytics.DimensionAttribute. The        
             * names of the JS object properties are given by the OData entity         type property names
             * representing the dimension attribute keys.
            */
            getAllAttributes(): any;

            /**
             * Get query result containing this dimension
             * @returns The query result object
            */
            getContainingQueryResult(): sap.ui.model.analytics.odata4analytics.QueryResult;

            /**
             * Get associated hierarchy
             * @returns The hierarchy object or null if there is none. It can         be an instance of class      
             *   odata4analytics.RecursiveHierarchy (TODO later: or a         leveled hierarchy). Use methods
             * isLeveledHierarchy and         isRecursiveHierarchy to determine object type.
            */
            getHierarchy(): any;

            /**
             * Get the key property
             * @returns The DataJS object representing the property for the         dimension key
            */
            getKeyProperty(): any;

            /**
             * Get label
             * @returns The (possibly language-dependent) label text for this         dimension
            */
            getLabelText(): string;

            /**
             * Get master data entity set for this dimension
             * @returns The master data entity set        for this dimension, or null, if it does not exist
            */
            getMasterDataEntitySet(): sap.ui.model.analytics.odata4analytics.EntitySet;

            /**
             * Get the name of the dimension
             * @returns The name of this dimension, which is identical to the         name of the dimension key
             * property in the entity type
            */
            getName(): string;

            /**
             * Get super-ordinate dimension
             * @returns The super-ordinate dimension or null if there is none
            */
            getSuperOrdinateDimension(): any;

            /**
             * Get text property related to this dimension
             * @returns The DataJS object representing the text property or         null if it does not exist
            */
            getTextProperty(): any;

            /**
             * Get indicator whether or not master data is available for this dimension
             * @returns True iff master data is available
            */
            hasMasterData(): boolean;
          }
          /**
           * Representation of a OData entity set.
           * @resource sap/ui/model/analytics/odata4analytics.js
          */
          export class EntitySet {


            /**
             * Create a representation of an OData entity set in the context of an analyticquery. Do not create
             * your own instances.
             * @param oModel DataJS object for the OData model containing this entity           set
             * @param oSchema DataJS object for the schema surrounding the container of           this entity set
             * @param oContainer DataJS object for the container holding this entity set
             * @param oEntitySet DataJS object for the entity set
             * @param oEntityType DataJS object for the entity type
            */
            constructor(oModel: any, oSchema: any, oContainer: any, oEntitySet: any, oEntityType: any);



            /**
             * Get entity type used for this entity set
             * @returns The DataJS object representing the entity type
            */
            getEntityType(): any;

            /**
             * Get the fully qualified name for this entity type
             * @returns The fully qualified name
            */
            getQName(): string;

            /**
             * Get full description for this entity set
             * @returns The DataJS object representing the entity set
            */
            getSetDescription(): any;

            /**
             * Get names of properties in this entity set that can be updated
             * @returns An object with individual JS properties for each         updatable property. For testing
             * whether propertyName is the name         of an updatable property, use        
             * <code>getUpdatablePropertyNameSet()[propertyName]</code>. The         included JS object properties
             * are all set to true.
            */
            getUpdatablePropertyNameSet(): any;
          }
          /**
           * Representation of a OData entity type.
           * @resource sap/ui/model/analytics/odata4analytics.js
          */
          export class EntityType {


            /**
             * Create a representation of an OData entity type in the context of an analyticquery. Do not create
             * your own instances.
             * @param oModel DataJS object for the OData model containing this entity           type
             * @param oSchema DataJS object for the schema containing this entity type
             * @param oEntityType DataJS object for the entity type
            */
            constructor(oModel: any, oSchema: any, oEntityType: any);



            /**
             * Find property by name
             * @param sPropertyName Property name
             * @returns The DataJS object representing the property or null if         it does not exist
            */
            findPropertyByName(sPropertyName: string): any;

            /**
             * Get the names of all properties with an associated hierarchy
             * @returns List of all property names
            */
            getAllHierarchyPropertyNames(): string[];

            /**
             * Get names of properties that can be filtered, that is they can be used in$filter expressions
             * @returns Array with names of properties that can be         filtered.
            */
            getFilterablePropertyNames(): string[];

            /**
             * Get heading of the property with specified name (identified by propertymetadata annotation
             * sap:heading)
             * @param sPropertyName Property name
             * @returns The heading string
            */
            getHeadingOfProperty(sPropertyName: string): string;

            /**
             * Get the hierarchy associated to a given property Based on the currentspecification, hierarchies are
             * always recursive. TODO: Extend behaviorwhen leveled hierarchies get in scope
             * @param sName Parameter name
             * @returns The hierarchy         object or null if it does not exist
            */
            getHierarchy(sName: string): sap.ui.model.analytics.odata4analytics.RecursiveHierarchy;

            /**
             * Get key properties of this type
             * @returns The list of key property names
            */
            getKeyProperties(): string[];

            /**
             * Get label of the property with specified name (identified by propertymetadata annotation sap:label)
             * @param sPropertyName Property name
             * @returns The label string
            */
            getLabelOfProperty(sPropertyName: string): string;

            /**
             * Get all properties
             * @returns Object with (JavaScript) properties, one for each (OData        entity type) property.
             * These (JavaScript) properties hold the        DataJS object representing the property
            */
            getProperties(): any;

            /**
             * Get properties for which filter restrictions have been specified
             * @returns Object with (JavaScript) properties, one for each         (OData entity type) property. The
             * property value is from         odata4analytics.EntityType.propertyFilterRestriction and        
             * indicates the filter restriction for this property.
            */
            getPropertiesWithFilterRestrictions(): any;

            /**
             * Get the fully qualified name for this entity type
             * @returns The fully qualified name
            */
            getQName(): string;

            /**
             * Get quick info of the property with specified name (identified by propertymetadata annotation
             * sap:quickinfo)
             * @param sPropertyName Property name
             * @returns The quick info string
            */
            getQuickInfoOfProperty(sPropertyName: string): string;

            /**
             * Get names of properties that must be filtered, that is they must appearin every $filter expression
             * @returns Array with names of properties that must be         filtered.
            */
            getRequiredFilterPropertyNames(): string[];

            /**
             * Get names of properties that can be sorted, that is they can be used in$orderby expressions
             * @returns Array with names of properties that can be         sorted.
            */
            getSortablePropertyNames(): string[];

            /**
             * Get the super-ordinate property related to the property with specifiedname (identified by property
             * metadata annotation sap:super-ordinate)
             * @param sPropertyName Property name
             * @returns The DataJS object representing the super-ordinate         property or null if it does not
             * exist
            */
            getSuperOrdinatePropertyOfProperty(sPropertyName: string): any;

            /**
             * Get the text property related to the property with specified name(identified by property metadata
             * annotation sap:text)
             * @param sPropertyName Property name
             * @returns The DataJS object representing the text property or         null if it does not exist
            */
            getTextPropertyOfProperty(sPropertyName: string): any;

            /**
             * Get full description for this entity type
             * @returns The DataJS object representing the entity type
            */
            getTypeDescription(): any;
          }
          /**
           * Representation of an entity type annotated with       sap:semantics="aggregate".
           * @resource sap/ui/model/analytics/odata4analytics.js
          */
          export class QueryResult {


            /**
             * Create a representation of an analytic query. Do not create your own instances.
             * @param oModel The analytical model containing this query result entity           set
             * @param oEntityType The OData entity type for this query
             * @param oEntitySet The OData entity set for this query offered by the           OData service
             * @param oParameterization The parameterization of this query, if any
            */
            constructor(oModel: sap.ui.model.analytics.odata4analytics.Model, oEntityType: sap.ui.model.analytics.odata4analytics.EntityType, oEntitySet: sap.ui.model.analytics.odata4analytics.EntitySet, oParameterization: sap.ui.model.analytics.odata4analytics.Parameterization);



            /**
             * Find dimension by name
             * @param sName Dimension name
             * @returns The dimension object with         this name or null if it does not exist
            */
            findDimensionByName(sName: string): sap.ui.model.analytics.odata4analytics.Dimension;

            /**
             * Find dimension by property name
             * @param sName Property name
             * @returns The dimension object to         which the given property name is related, because the
             * property         holds the dimension key, its text, or is an attribute of this         dimension. If
             * no such dimension exists, null is returned.
            */
            findDimensionByPropertyName(sName: string): sap.ui.model.analytics.odata4analytics.Dimension;

            /**
             * Find measure by name
             * @param sName Measure name
             * @returns The measure object with this         name or null if it does not exist
            */
            findMeasureByName(sName: string): sap.ui.model.analytics.odata4analytics.Measure;

            /**
             * Find measure by property name
             * @param sName Property name
             * @returns The measure object to which         the given property name is related, because the
             * property holds         the raw measure value or its formatted value. If no such measure        
             * exists, null is returned.
            */
            findMeasureByPropertyName(sName: string): sap.ui.model.analytics.odata4analytics.Measure;

            /**
             * Get the names of all dimensions included in the query result
             * @returns List of all dimension names
            */
            getAllDimensionNames(): string[];

            /**
             * Get all dimensions included in this query result
             * @returns An object with individual JS properties for each         dimension included in the query
             * result. The JS object properties         all are objects of type odata4analytics.Dimension. The     
             *    names of the JS object properties are given by the OData entity         type property names
             * representing the dimension keys.
            */
            getAllDimensions(): any;

            /**
             * Get the names of all measures included in the query result
             * @returns List of all measure names
            */
            getAllMeasureNames(): string[];

            /**
             * Get all measures included in this query result
             * @returns An object with individual JS properties for each         measure included in the query
             * result. The JS object properties         all are objects of type odata4analytics.Measure. The       
             *  names of the JS object properties are given by the OData entity         type property names
             * representing the measure raw values.
            */
            getAllMeasures(): any;

            /**
             * Get the entity set representing this query result in the OData model
             * @returns The OData entity set         representing this query result
            */
            getEntitySet(): sap.ui.model.analytics.odata4analytics.EntitySet;

            /**
             * Get the entity type defining the type of this query result in the ODatamodel
             * @returns The OData entity type for         this query result
            */
            getEntityType(): sap.ui.model.analytics.odata4analytics.EntityType;

            /**
             * Get the analytical model containing the entity set for this query result
             * @returns The analytical representation of the OData model
            */
            getModel(): any;

            /**
             * Get the name of the query result
             * @returns The fully qualified name of the query result, which is         identical with the name of
             * the entity set representing the query         result in the OData service
            */
            getName(): string;

            /**
             * Get the parameterization of this query result
             * @returns The object for the         parameterization or null if the query result is not        
             * parameterized
            */
            getParameterization(): sap.ui.model.analytics.odata4analytics.Parameterization;

            /**
             * Get property holding the totaled property list
             * @returns The DataJS object representing this property
            */
            getTotaledPropertiesListProperty(): any;
          }
          /**
           * Representation of a $orderby expression for an OData entity type.
           * @resource sap/ui/model/analytics/odata4analytics.js
          */
          export class SortExpression {


            /**
             * Create a representation of an order by expression for a given entity type. Itcan be rendered as
             * value for the $orderby system query option.
             * @param oModel DataJS object for the OData model containing this entity           type
             * @param oSchema DataJS object for the schema containing this entity type
             * @param oEntityType object for the entity type
            */
            constructor(oModel: any, oSchema: any, oEntityType: sap.ui.model.analytics.odata4analytics.EntityType);



            /**
             * Add a condition to the order by expression. It replaces any previously specifiedsort order for the
             * property.
             * @param sPropertyName The name of the property bound in the condition
             * @param sSortOrder sorting order used for the condition
             * @returns This object for method         chaining
            */
            addSorter(sPropertyName: string, sSortOrder: any): sap.ui.model.analytics.odata4analytics.SortExpression;

            /**
             * Clear expression from any sort conditions that may have been setpreviously
            */
            clear(): void;

            /**
             * Get description for this entity type
             * @returns The object representing the         entity type
            */
            getEntityType(): sap.ui.model.analytics.odata4analytics.EntityType;

            /**
             * Get the first SAPUI5 Sorter object.
             * @returns first sorter object or null if empty
            */
            getExpressionAsUI5Sorter(): sap.ui.model.Sorter;

            /**
             * Get an array of SAPUI5 Sorter objects corresponding to this expression.
             * @returns List of sorter objects representing         this expression
            */
            getExpressionsAsUI5SorterArray(): sap.ui.model.Sorter[];

            /**
             * Get the value for the OData system query option $orderby corresponding tothis expression.
             * @param oSelectedPropertyNames Object with properties requested for $select
             * @returns The $orderby value for the sort expressions
            */
            getURIOrderByOptionValue(oSelectedPropertyNames: any): string;

            /**
             * Removes the order by expression for the given property name from the listof order by expression. If
             * no order by expression with this property nameexists the method does nothing.
             * @param sPropertyName The name of the property to be removed from the           condition
            */
            removeSorter(sPropertyName: string): void;
          }
          /**
           * Representation of a $filter expression for an OData entity type.
           * @resource sap/ui/model/analytics/odata4analytics.js
          */
          export class FilterExpression {


            /**
             * Create a representation of a filter expression for a given entity type. It can be rendered as value
             * for the $filter systemquery option.
             * @param oModel DataJS object for the OData model containing this entity type
             * @param oSchema DataJS object for the schema containing this entity type
             * @param oEntityType object for the entity type
            */
            constructor(oModel: any, oSchema: any, oEntityType: sap.ui.model.analytics.odata4analytics.EntityType);



            /**
             * Add a condition to the filter expression.Multiple conditions on the same property are combined with
             * a logical OR first, and in a second step conditions fordifferent properties are combined with a
             * logical AND.
             * @param sPropertyName The name of the property bound in the condition
             * @param sOperator operator used for the condition
             * @param oValue value to be used for this condition
             * @param oValue2 (optional) as second value to be used for this condition
             * @returns This object for method chaining
            */
            addCondition(sPropertyName: string, sOperator: typeof sap.ui.model.FilterOperator, oValue: any, oValue2: any): sap.ui.model.analytics.odata4analytics.FilterExpression;

            /**
             * Add a set condition to the filter expression.A set condition tests if the value of a property is
             * included in a set of given values. It is a convenience method forthis particular use case
             * eliminating the need for multiple API calls.
             * @param sPropertyName The name of the property bound in the condition
             * @param aValues values defining the set
             * @returns This object for method chaining
            */
            addSetCondition(sPropertyName: string, aValues: any[]): sap.ui.model.analytics.odata4analytics.FilterExpression;

            /**
             * Add an array of UI5 filter conditions to the filter expression.The UI5 filter condition is combined
             * with the other given conditions using a logical AND. This methodis particularly useful for passing
             * forward already created UI5 filter arrays.
             * @param aUI5Filter Array of UI5 filter objects
             * @returns This object for method chaining
            */
            addUI5FilterConditions(aUI5Filter: sap.ui.model.Filter[]): sap.ui.model.analytics.odata4analytics.FilterExpression;

            /**
             * Check if request is compliant with basic filter constraints expressed in metadata:(a) all properties
             * required in the filter expression have been referenced (b) the single-value filter restrictions have
             * been obeyed
             * @returns The value true. In case the expression violates some of the rules, an exception with some
             * explanatory         message is thrown
            */
            checkValidity(): boolean;

            /**
             * Clear expression from any conditions that may have been set previously
            */
            clear(): void;

            /**
             * Get description for this entity type
             * @returns The object representing the entity type
            */
            getEntityType(): sap.ui.model.analytics.odata4analytics.EntityType;

            /**
             * Get an array of SAPUI5 Filter objects corresponding to this expression.
             * @returns List of filter objects representing this expression
            */
            getExpressionAsUI5FilterArray(): sap.ui.model.Filter[];

            /**
             * Get the value for the OData system query option $filter corresponding to this expression.
             * @returns The $filter value for the filter expression
            */
            getURIFilterOptionValue(): string;

            /**
             * Remove all conditions for some property from the filter expression.All previously set conditions for
             * some property are removed from the filter expression.
             * @param sPropertyName The name of the property bound in the condition
             * @returns This object for method chaining
            */
            removeConditions(sPropertyName: string): sap.ui.model.analytics.odata4analytics.FilterExpression;
          }
          /**
           * Representation of an entity type annotated with       sap:semantics="parameters".
           * @resource sap/ui/model/analytics/odata4analytics.js
          */
          export class Parameterization {


            /**
             * Create a representation of a parameterization for an analytic query. Do not create your own
             * instances.
             * @param oEntityType The OData entity type for this parameterization
             * @param oEntitySet The OData entity set for this parameterization offered           by the OData
             * service
            */
            constructor(oEntityType: sap.ui.model.analytics.odata4analytics.EntityType, oEntitySet: sap.ui.model.analytics.odata4analytics.EntitySet);



            /**
             * Find parameter by name
             * @param sName Parameter name
             * @returns The parameter object with         this name or null if it does not exist
            */
            findParameterByName(sName: string): sap.ui.model.analytics.odata4analytics.Parameter;

            /**
             * Get the names of all parameters part of the parameterization
             * @returns List of all parameter names
            */
            getAllParameterNames(): string[];

            /**
             * Get all parameters included in this parameterization
             * @returns An object with individual JS properties for each         parameter included in the query
             * result. The JS object properties         all are objects of type odata4analytics.Parameter. The     
             *    names of the JS object properties are given by the OData entity         type property names
             * representing the parameter keys.
            */
            getAllParameters(): any;

            /**
             * Get the entity set representing this query result in the OData model
             * @returns The OData entity set         representing this query result
            */
            getEntitySet(): sap.ui.model.analytics.odata4analytics.EntitySet;

            /**
             * Get the entity type defining the type of this query result in the ODatamodel
             * @returns The OData entity type for         this query result
            */
            getEntityType(): sap.ui.model.analytics.odata4analytics.EntityType;

            /**
             * Get the name of the parameter
             * @returns The name of the parameterization, which is identical         with the name of the entity
             * set representing the         parameterization in the OData service
            */
            getName(): string;

            /**
             * Get navigation property to query result
             * @returns The parameter object with         this name or null if it does not exist
            */
            getNavigationPropertyToQueryResult(): sap.ui.model.analytics.odata4analytics.QueryResult;
          }
          /**
           * Representation of a recursive hierarchy.
           * @resource sap/ui/model/analytics/odata4analytics.js
          */
          export class RecursiveHierarchy {


            /**
             * Create a representation of a recursive hierarchy defined on one multipleproperties in an OData
             * entity type query. Do not create your own instances.
             * @param oEntityType object for the entity type
             * @param oNodeIDProperty DataJS object for the property holding the           hierarchy node ID
             * identifying the hierarchy node to which the           OData entry belongs
             * @param oParentNodeIDProperty DataJS object for the property holding the           node ID of the
             * parent of the hierarchy node pointed to by the           value of oNodeIDProperty
             * @param oNodeLevelProperty DataJS object for the property holding the           level number for the
             * of the hierarchy node pointed to by the value           of oNodeIDProperty
             * @param oNodeValueProperty DataJS object for the property holding the data           value for the of
             * the hierarchy node pointed to by the value of           oNodeIDProperty
            */
            constructor(oEntityType: EntityType, oNodeIDProperty: any, oParentNodeIDProperty: any, oNodeLevelProperty: any, oNodeValueProperty: any);



            /**
             * Get the property holding the node ID of the hierarchy node
             * @returns The DataJS object representing this property
            */
            getNodeIDProperty(): any;

            /**
             * Get the property holding the level of the hierarchy node
             * @returns The DataJS object representing this property
            */
            getNodeLevelProperty(): any;

            /**
             * Get the property holding the value that is structurally organized by thehierarchy
             * @returns The DataJS object representing this property
            */
            getNodeValueProperty(): any;

            /**
             * Get the property holding the parent node ID of the hierarchy node
             * @returns The DataJS object representing this property
            */
            getParentNodeIDProperty(): any;

            /**
             * Get indicator if this is a leveled hierarchy
             * @returns False
            */
            isLeveledHierarchy(): boolean;

            /**
             * Get indicator if this is a recursive hierarchy
             * @returns True
            */
            isRecursiveHierarchy(): boolean;
          }
          /**
           * Creation of URIs for fetching query results.
           * @resource sap/ui/model/analytics/odata4analytics.js
          */
          export class QueryResultRequest {


            /**
             * Create a request object for interaction with a query result.
             * @param oQueryResult Description of a query parameterization
             * @param oParameterizationRequest Request object for           interactions with the parameterization
             * of this query. Only           required if the query service includes parameters.
            */
            constructor(oQueryResult: sap.ui.model.analytics.odata4analytics.QueryResult, oParameterizationRequest?: sap.ui.model.analytics.odata4analytics.ParameterizationRequest);



            /**
             * Add one or more dimensions to the aggregation level
             * @param aDimensionName Array of dimension names to be added to the already defined          
             * aggregation level.
            */
            addToAggregationLevel(aDimensionName: any): void;

            /**
             * Get the names of the dimensions included in the aggregation level
             * @returns The dimension names included in the aggregation level
            */
            getAggregationLevel(): any[];

            /**
             * Get details about a dimensions included in the aggregation level
             * @param sDImensionName Name of a dimension included in the aggregation level of this          
             * request, for which details shall be returned
             * @returns An object with three properties named key and text,         both with Boolean values
             * indicating whether the key and text of         this dimension are included in this request. The
             * third property         named attributes is an array of attribute names of this         dimension
             * included in this request, or null, if there are none.
            */
            getAggregationLevelDetails(sDImensionName: any): any;

            /**
             * Get the filter expression for this request.Expressions are represented by separate objects. If none
             * exists so far, anew expression object gets created.
             * @returns The filter object         associated to this request.
            */
            getFilterExpression(): sap.ui.model.analytics.odata4analytics.FilterExpression;

            /**
             * Get the names of the measures included in the query result request
             * @returns The measure names included in the query result request
            */
            getMeasureNames(): any[];

            /**
             * Retrieves the current parametrization request
            */
            getParameterizationRequest(): any;

            /**
             * Get the description of the query result on which this request operates on
             * @returns Description of a query         result
            */
            getQueryResult(): sap.ui.model.analytics.odata4analytics.QueryResult;

            /**
             * Returns the current page boundaries as object with properties<code>start</code> and
             * <code>end</code>. If the end of the page isunbounded, <code>end</code> is null.
             * @returns the current page boundaries as object
            */
            getResultPageBoundaries(): any;

            /**
             * Get the sort expression for this request.Expressions are represented by separate objects. If none
             * exists so far, anew expression object gets created.
             * @returns The sort object         associated to this request.
            */
            getSortExpression(): sap.ui.model.analytics.odata4analytics.SortExpression;

            /**
             * Get the value of an query option for the OData request URI correspondingto this request.
             * @param sQueryOptionName Identifies the query option: $select,           $filter,$orderby ... or any
             * custom query option
             * @returns The value of the requested query option or null, if         this option is not used for the
             * OData request.
            */
            getURIQueryOptionValue(sQueryOptionName: String): String;

            /**
             * Get the URI to locate the entity set for the query result.
             * @param sServiceRootURI (optional) Identifies the root of the OData           service
             * @returns The resource path of the URI pointing to the entity         set. It is a relative URI
             * unless a service root is given, which         would then prefixed in order to return a complete URL.
            */
            getURIToQueryResultEntitySet(sServiceRootURI: String): String;

            /**
             * Get the unescaped URI to fetch the query result.
             * @param sServiceRootURI (optional) Identifies the root of the OData           service
             * @param sResourcePath (optional) OData resource path to be considered.           If provided, it
             * overwrites any parameterization object that           might have been specified separately.
             * @returns The unescaped URI that contains the OData resource path         and OData system query
             * options to express the aggregation level,         filter expression and further options.
            */
            getURIToQueryResultEntries(sServiceRootURI: String, sResourcePath: String): String;

            /**
             * Specify which dimension components shall be included in the query result.The settings get applied to
             * the currently defined aggregation level.
             * @param sDimensionName Name of the dimension for which the settings get applied.           Specify
             * null to apply the settings to all dimensions in the           aggregation level.
             * @param bIncludeKey Indicator whether or not to include the dimension key in the           query
             * result. Pass null to keep current setting.
             * @param bIncludeText Indicator whether or not to include the dimension text (if           available)
             * in the query result. Pass null to keep current           setting.
             * @param aAttributeName Array of dimension attribute names to be included in the           result.
             * Pass null to keep current setting. This argument is           ignored if sDimensionName is null.
            */
            includeDimensionKeyTextAttributes(sDimensionName: any, bIncludeKey: any, bIncludeText: any, aAttributeName: any): void;

            /**
             * Specify which measure components shall be included in the query result.The settings get applied to
             * the currently set measures.
             * @param sMeasureName Name of the measure for which the settings get applied.           Specify null
             * to apply the settings to all currently set           measures.
             * @param bIncludeRawValue Indicator whether or not to include the raw value in the query          
             * result. Pass null to keep current setting.
             * @param bIncludeFormattedValue Indicator whether or not to include the formatted value (if          
             * available) in the query result. Pass null to keep current           setting.
             * @param bIncludeUnit Indicator whether or not to include the unit (if available) in           the
             * query result. Pass null to keep current setting.
            */
            includeMeasureRawFormattedValueUnit(sMeasureName: any, bIncludeRawValue: any, bIncludeFormattedValue: any, bIncludeUnit: any): void;

            /**
             * Remove one or more dimensions from the aggregation level. The method alsoremoved a potential sort
             * expression on the dimension.
             * @param aDimensionName Array of dimension names to be removed from the already           defined
             * aggregation level.
            */
            removeFromAggregationLevel(aDimensionName: any): void;

            /**
             * Set the aggregation level for the query result request. By default, thequery result will include the
             * properties holding the keys of the givendimensions. This setting can be changed
             * usingincludeDimensionKeyTextAttributes.
             * @param aDimensionName Array of dimension names to be part of the aggregation level.           If
             * null, the aggregation level includes all dimensions, if           empty, no dimension is included.
            */
            setAggregationLevel(aDimensionName: any): void;

            /**
             * Set the filter expression for this request.Expressions are represented by separate objects. Calling
             * this methodreplaces the filter object maintained by this request.
             * @param oFilter The filter object to be associated with this request.
            */
            setFilterExpression(oFilter: sap.ui.model.analytics.odata4analytics.FilterExpression): void;

            /**
             * Set the measures to be included in the query result request. By default,the query result will
             * include the properties holding the raw values ofthe given measures. This setting can be changed
             * usingincludeMeasureRawFormattedValueUnit.
             * @param aMeasureName Array of measure names to be part of the query result request.           If
             * null, the request includes all measures, if empty, no           measure is included.
            */
            setMeasures(aMeasureName: any): void;

            /**
             * Set the parameterization request required for interactions with the queryresult of parameterized
             * queries. This method provides an alternative wayto assign a parameterization request to a query
             * result request.
             * @param oParameterizationRequest Request object for interactions with the parameterization of        
             *   this query
            */
            setParameterizationRequest(oParameterizationRequest: any): void;

            /**
             * Set further options to be applied for the OData request to fetch thequery result
             * @param bIncludeEntityKey Indicates whether or not the entity key           should be returned for
             * every entry in the query result.           Default is not to include it. Pass null to keep current  
             *         setting.
             * @param bIncludeCount Indicates whether or not the result shall           include a count for the
             * returned entities. Default is not to           include it. Pass null to keep current setting.
             * @param bReturnNoEntities Indicates whether or not the result shall           be empty. This will
             * translate to $top=0 in the OData request and override           any setting done with
             * setResultPageBoundaries. The default is not to           suppress entities in the result. Pass null
             * to keep current setting.           The main use case for this option is to create a request         
             *  with $inlinecount returning an entity count.
            */
            setRequestOptions(bIncludeEntityKey: Boolean, bIncludeCount: Boolean, bReturnNoEntities: Boolean): void;

            /**
             * Set the resource path to be considered for the OData request URI of thisquery request object. This
             * method provides an alternative way to assign apath comprising a parameterization. If a path is
             * provided, it overwritesany parameterization object that might have been specified separately.
             * @param sResourcePath Resource path pointing to the entity set of the query result.           Must
             * include a valid parameterization if query contains           parameters.
            */
            setResourcePath(sResourcePath: any): void;

            /**
             * Specify that only a page of the query result shall be returned. A page isdescribed by its
             * boundaries, that are row numbers for the first and lastrows in the query result to be returned.
             * @param start The first row of the query result to be returned.           Numbering starts at 1.
             * Passing null is equivalent to start           with the first row.
             * @param end The last row of the query result to be returned. Passing           null is equivalent to
             * get all rows up to the end of the query           result.
            */
            setResultPageBoundaries(start: Number, end: Number): void;

            /**
             * Set the sort expression for this request.Expressions are represented by separate objects. Calling
             * this methodreplaces the sort object maintained by this request.
             * @param oSorter The sort object to be associated with this request.
            */
            setSortExpression(oSorter: sap.ui.model.analytics.odata4analytics.SortExpression): void;
          }
          /**
           * Representation of a dimension attribute.
           * @resource sap/ui/model/analytics/odata4analytics.js
          */
          export class DimensionAttribute {


            /**
             * Create a representation of a dimension attribute provided by an analyticquery. Do not create your
             * own instances.
             * @param oQueryResult The query result containing this dimension attribute
             * @param oProperty The DataJS object object representing the dimension           attribute
            */
            constructor(oQueryResult: sap.ui.model.analytics.odata4analytics.QueryResult, oProperty: any);



            /**
             * Get dimension
             * @returns The dimension object         containing this attribute
            */
            getDimension(): sap.ui.model.analytics.odata4analytics.Dimension;

            /**
             * Get the key property
             * @returns The DataJS object representing the property for the key         of this dimension attribute
            */
            getKeyProperty(): any;

            /**
             * Get label
             * @returns The (possibly language-dependent) label text for this         dimension attribute
            */
            getLabelText(): string;

            /**
             * Get the name of the dimension attribute
             * @returns The name of the dimension attribute, which is identical         to the name of the property
             * in the entity type holding the         attribute value
            */
            getName(): string;

            /**
             * Get text property related to this dimension attribute
             * @returns The DataJS object representing the text property or         null if it does not exist
            */
            getTextProperty(): any;
          }
          /**
           * Creation of URIs for query parameterizations.
           * @resource sap/ui/model/analytics/odata4analytics.js
          */
          export class ParameterizationRequest {


            /**
             * Create a request object for interaction with a query parameterization.
             * @param oParameterization Description of a query parameterization
            */
            constructor(oParameterization: sap.ui.model.analytics.odata4analytics.Parameterization);



            /**
             * Get the description of the parameterization on which this requestoperates on
             * @returns Description of a         query parameterization
            */
            getParameterization(): sap.ui.model.analytics.odata4analytics.Parameterization;

            /**
             * Get the URI to locate the entity set for the query parameterization.
             * @param sServiceRootURI (optional) Identifies the root of the OData           service
            */
            getURIToParameterizationEntitySet(sServiceRootURI: String): void;

            /**
             * Get the URI to locate the parameterization entity for the values assignedto all parameters
             * beforehand. Notice that a value must be supplied forevery parameter including those marked as
             * optional. For optionalparameters, assign the special value that the service provider uses as
             * an"omitted" value. For example, for services based on BW Easy Queries, thiswould be an empty string.
             * @param sServiceRootURI (optional) Identifies the root of the OData           service
            */
            getURIToParameterizationEntry(sServiceRootURI: String): void;

            /**
             * Assign a value to a parameter
             * @param sParameterName Name of the parameter. In case of a range           value, provide the name of
             * the lower boundary parameter.
             * @param sValue Assigned value. Pass null to remove a value assignment.
             * @param sToValue Omit it or set it to null for single values. If set,           it will be assigned
             * to the upper boundary parameter
            */
            setParameterValue(sParameterName: String, sValue: String, sToValue: String): void;
          }
          /**
           * Creation of URIs for fetching a query parameter value set.
           * @resource sap/ui/model/analytics/odata4analytics.js
          */
          export class ParameterValueSetRequest {


            /**
             * Create a request object for interaction with a query parameter value help.
             * @param oParameter Description of a query parameter
            */
            constructor(oParameter: sap.ui.model.analytics.odata4analytics.Parameter);



            /**
             * Get the filter expression for this request.Expressions are represented by separate objects. If none
             * exists so far, anew expression object gets created.
             * @returns The filter object         associated to this request.
            */
            getFilterExpression(): sap.ui.model.analytics.odata4analytics.FilterExpression;

            /**
             * Get the sort expression for this request.Expressions are represented by separate objects. If none
             * exists so far, anew expression object gets created.
             * @returns The sort object         associated to this request.
            */
            getSortExpression(): sap.ui.model.analytics.odata4analytics.SortExpression;

            /**
             * Get the value of an query option for the OData request URI correspondingto this request.
             * @param sQueryOptionName Identifies the query option: $select,           $filter,... or any custom
             * query option
             * @returns The value of the requested query option or null, if         this option is not used for the
             * OData request.
            */
            getURIQueryOptionValue(sQueryOptionName: String): String;

            /**
             * Get the unescaped URI to fetch the parameter value set.
             * @param sServiceRootURI (optional) Identifies the root of the OData           service
             * @returns The unescaped URI that contains the OData resource path         and OData system query
             * options to express the request for the         parameter value set..
            */
            getURIToParameterValueSetEntries(sServiceRootURI: String): String;

            /**
             * Specify which components of the parameter shall be included in the valueset.
             * @param bIncludeText Indicator whether or not to include the parameter text (if           available)
             * in the value set. Pass null to keep current           setting.
            */
            includeParameterText(bIncludeText: any): void;

            /**
             * Set the filter expression for this request.Expressions are represented by separate objects. Calling
             * this methodreplaces the filter object maintained by this request.
             * @param oFilter The filter object to be associated with this request.
            */
            setFilterExpression(oFilter: sap.ui.model.analytics.odata4analytics.FilterExpression): void;

            /**
             * Set the sort expression for this request.Expressions are represented by separate objects. Calling
             * this methodreplaces the sort object maintained by this request.
             * @param oSorter The sort object to be associated with this request.
            */
            setSortExpression(oSorter: sap.ui.model.analytics.odata4analytics.SortExpression): void;
          }
          /**
           * Creation of URIs for fetching a query dimension value set.
           * @resource sap/ui/model/analytics/odata4analytics.js
          */
          export class DimensionMemberSetRequest {


            /**
             * Create a request object for interaction with a dimension value help. Such avalue help is served by
             * either the query result entity set, in which case thereturned dimension members are limited to those
             * also used in the query resultdata. Or, the value help is populated by a master data entity set, if
             * madeavailable by the service. In this case, the result will include all validmembers for that
             * dimension.
             * @param oDimension Description of a dimension
             * @param oParameterizationRequest (optional) Request object for           interactions with the
             * parameterization of the query result or (not           yet supported) master data entity set Such an
             * object is required           if the entity set holding the dimension members includes          
             * parameters.
             * @param bUseMasterData (optional) Indicates use of master data for           determining the
             * dimension members.
            */
            constructor(oDimension: sap.ui.model.analytics.odata4analytics.Dimension, oParameterizationRequest: sap.ui.model.analytics.odata4analytics.ParameterizationRequest, bUseMasterData: boolean);



            /**
             * Get the filter expression for this request.Expressions are represented by separate objects. If none
             * exists so far, anew expression object gets created.
             * @returns The filter object         associated to this request.
            */
            getFilterExpression(): sap.ui.model.analytics.odata4analytics.FilterExpression;

            /**
             * Returns the current page boundaries as object with properties<code>start</code> and
             * <code>end</code>. If the end of the page isunbounded, <code>end</code> is null.
             * @returns the current page boundaries as object
            */
            getResultPageBoundaries(): any;

            /**
             * Get the sort expression for this request.Expressions are represented by separate objects. If none
             * exists so far, anew expression object gets created.
             * @returns The sort object         associated to this request.
            */
            getSortExpression(): sap.ui.model.analytics.odata4analytics.SortExpression;

            /**
             * Get the value of an query option for the OData request URI correspondingto this request.
             * @param sQueryOptionName Identifies the query option: $select,           $filter,... or any custom
             * query option
             * @returns The value of the requested query option or null, if         this option is not used for the
             * OData request.
            */
            getURIQueryOptionValue(sQueryOptionName: String): String;

            /**
             * Get the URI to locate the entity set for the dimension memebers.
             * @param sServiceRootURI (optional) Identifies the root of the OData           service
             * @returns The resource path of the URI pointing to the entity         set. It is a relative URI
             * unless a service root is given, which         would then prefixed in order to return a complete URL.
            */
            getURIToDimensionMemberEntitySet(sServiceRootURI: String): String;

            /**
             * Get the unescaped URI to fetch the dimension members, optionallyaugmented by text and attributes.
             * @param sServiceRootURI (optional) Identifies the root of the OData           service
             * @returns The unescaped URI that contains the OData resource path         and OData system query
             * options to express the request for the         parameter value set..
            */
            getURIToDimensionMemberEntries(sServiceRootURI: String): String;

            /**
             * Set the filter expression for this request.Expressions are represented by separate objects. Calling
             * this methodreplaces the filter object maintained by this request.
             * @param oFilter The filter object to be associated with this request.
            */
            setFilterExpression(oFilter: sap.ui.model.analytics.odata4analytics.FilterExpression): void;

            /**
             * Set the parameterization request required for retrieving dimensionmembers directly from the query
             * result, if it is parameterized.
             * @param oParameterizationRequest Request object for interactions with the parameterization of        
             *   this query result
            */
            setParameterizationRequest(oParameterizationRequest: any): void;

            /**
             * Set further options to be applied for the OData request
             * @param bIncludeCount Indicates whether or not the result shall           include a count for the
             * returned entities. Default is not to           include it. Pass null to keep current setting.
            */
            setRequestOptions(bIncludeCount: Boolean): void;

            /**
             * Specify that only a page of the query result shall be returned. A page isdescribed by its
             * boundaries, that are row numbers for the first and lastrows in the query result to be returned.
             * @param start The first row of the query result to be returned.           Numbering starts at 1.
             * Passing null is equivalent to start           with the first row.
             * @param end The last row of the query result to be returned. Passing           null is equivalent to
             * get all rows up to the end of the query           result.
            */
            setResultPageBoundaries(start: Number, end: Number): void;

            /**
             * Set the sort expression for this request.Expressions are represented by separate objects. Calling
             * this methodreplaces the sort object maintained by this request.
             * @param oSorter The sort object to be associated with this request.
            */
            setSortExpression(oSorter: sap.ui.model.analytics.odata4analytics.SortExpression): void;
          }
        }
        /**
         * Tree binding implementation for OData entity sets with aggregate semantics.Note on the handling of
         * different count modes:The AnalyticalBinding always uses the OData $inlinecount system query option
         * to determine the totalcount of matching entities. It ignores the default count mode set in the
         * ODataModel instance and thecount mode specified in the binding parameters. If the default count mode
         * is None, a warning is addedto the log to remind the application that OData requests generated by the
         * AnalyticalBinding will includea $inlinecount. If a count mode has been specified in the binding
         * parameters, an error message will belogged if it is None, because the binding will still add the
         * $inlinecount to OData requests. If abinding count mode is set to Request or Both, a warning will be
         * logged to remind the application thatthe OData requests generated by the AnalyticalBinding will
         * include a $inlinecount.
         * @resource sap/ui/model/analytics/AnalyticalBinding.js
        */
        export class AnalyticalBinding extends sap.ui.model.TreeBinding {






          /**
           * Sets filters for matching only a subset of the entities in the bound OData entity set.Invoking this
           * function resets the state of the binding. Subsequent data requests such as calls to
           * getNodeContexts() willneed to trigger OData requests in order to fetch the data that are in line
           * with these filters.
           * @param aFilter an Array of sap.ui.model.Filter objects or a single Filter instance.
           * @param sFilterType Type of the filter which should be adjusted.
           * @returns returns <code>this</code> to facilitate method chaining
          */
          filter(aFilter: sap.ui.model.Filter[] | sap.ui.model.Filter, sFilterType?: typeof sap.ui.model.FilterType): sap.ui.model.analytics.AnalyticalBinding;

          /**
           * Gets the analytical information for a column with a given name.
           * @param sColumnName the column name.
           * @returns analytical information for the column; see {@link #updateAnalyticalInfo}           for an
           * explanation of the object structure
          */
          getAnalyticalInfoForColumn(sColumnName: any): any;

          /**
           * Gets analytical metadata for the bound OData entity set.
           * @returns analytical metadata for the bound OData entity set
          */
          getAnalyticalQueryResult(): sap.ui.model.analytics.odata4analytics.QueryResult;

          /**
           * Gets details about the dimension properties included in the bound OData entity set.
           * @returns details for every dimension property addressed by its name. The details object provides
           * these properties: name of the dimension,keyPropertyName for the name of the property holding the
           * dimension key, textPropertyName for the name of the property holding thetext for the dimension,
           * aAttributeName listing all properties holding dimension attributes, grouped as indicator whether or
           * not thisdimension is currently grouped, and analyticalInfo, which contains the binding information
           * for this dimension passed from theAnalyticalBinding's consumer via call to function
           * updateAnalyticalInfo.
          */
          getDimensionDetails(): any;

          /**
           * Get a download URL with the specified format considering thesort/filter/custom parameters.The
           * download URL also takes into account the selected dimensions and measures,depending on the given
           * column definitions of the AnalyticalTable.This is based on the visible/inResult flags of the
           * columns, as well as integrity dependencies,e.g. for mandatory Unit properties.
           * @since 1.24
           * @param sFormat Value for the $format Parameter
           * @returns URL which can be used for downloading
          */
          getDownloadUrl(sFormat: string): string;

          /**
           * Gets the names of the filterable properties in the bound OData entity set.
           * @returns names of properties that can be filtered.
          */
          getFilterablePropertyNames(): any[];

          /**
           * Gets a printable name for a group.The printable name follows the pattern is
           * <code>&lt;label&gt;:&lt;key-value&gt;[-&lt;text-value&gt;]</code>,where <code>label</code> is the
           * label of the dimension property used at the aggregation level for the group,<code>key-value</code>
           * is the key value of that dimension for the group, and <code>text-value</code> is thevalue of the
           * associated text property, if it is also used in the binding.Whenever a formatter function has been
           * defined for a column displaying the key or text of this dimension, the return valueof this function
           * is applied for the group name instead of the respective key or text value.
           * @param oContext the parent context identifying the requested group.
           * @param iLevel the level number of oContext (because the context might occur at multiple levels)
           * @returns a printable name for the group.
          */
          getGroupName(oContext: sap.ui.model.Context, iLevel: number): string;

          /**
           * Gets the total number of contexts contained in a group, if known.For a given group, be aware that
           * the group size might vary over time. In principle, this can happen if thebound set of OData entities
           * includes measure properties with amount or quantity values. The AnalyticalBindingrecognizes
           * situations where the OData service returns multiple entries for a single group entry due to the fact
           * that ameasure property cannot be aggregated properly, because an amount exists in multiple
           * currencies or a quantity existsin multiple units. In such situations, the AnalyticalBinding
           * substitutes these entries by a single representative, andthe group size gets reduced by the count of
           * duplicate entries. Finally, since the Binding does not always fetch all children ofa group at once,
           * but only a page with a certain range, such size changes might happen after every page access.
           * @param oContext the parent context identifying the requested group of child contexts.
           * @param iLevel the level number of oContext (because the context might occur at multiple levels)
           * @returns The currently known group size, or -1, if not yet determined
          */
          getGroupSize(oContext: sap.ui.model.Context, iLevel: number): number;

          /**
           * Gets details about the measure properties included in the bound OData entity set.
           * @returns details for every measure property addressed by its name. The details object provides these
           * properties: name of the measure,rawValuePropertyName for the name of the property holding the raw
           * value, unitPropertyName for the name of the property holding the relatedvalue unit or currency, if
           * any, and analyticalInfo, which contains the binding information for this measure passed from
           * theAnalyticalBinding's consumer via call to function updateAnalyticalInfo.
          */
          getMeasureDetails(): any;

          /**
           * Returns a metadata object for class sap.ui.model.analytics.AnalyticalBinding.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Gets child contexts for a specified parent context.Contexts are returned in a stable order imposed
           * by thedimension property that defines this aggregation level beneath the parent context: Either a
           * sort order has been specified for this property,or the entries are returned in ascending order of
           * the values of this dimension property by default.If any of the requested data is missing, an OData
           * request will be triggered to load it.
           * @param mParameters specifying the aggregation level for which contexts shall be fetched. Supported
           * parameters are:<ul><li>oContext: parent context identifying the requested group of child
           * contexts</li><li>level: level number for oContext, because it might occur at multiple levels;
           * context with group ID <code>"/"</code> has level 0</li><li>numberOfExpandedLevels: number of child
           * levels that shall be fetched automatically</li><li>startIndex: index of first child entry to return
           * from the parent context (zero-based)</li><li>length: number of entries to return; counting begins at
           * the given start index</li><li>threshold: number of additional entries that shall be locally
           * available in the binding for subsequentaccesses to child entries of the given parent context.
           * </li></ul>
           * @returns Array containing the requested contexts of class sap.ui.model.Context, limited by the
           * number of entries contained           in the entity set at that aggregation level.           The
           * array will contain less than the requested number of contexts, if some are not locally available and
           * an OData request is           pending to fetch them. In this case, if the parameter
           * numberOfExpandedLevels > 0, the array will be completely empty.
          */
          getNodeContexts(mParameters: any): any[];

          /**
           * Gets the metadata of a property with a given name.
           * @param sPropertyName The property name.
          */
          getProperty(sPropertyName: string): any;

          /**
           * Gets the label of a property with a given name.
           * @param sPropertyName The property name.
           * @returns The heading maintained for this property or null if it does not exist.
          */
          getPropertyHeading(sPropertyName: string): string;

          /**
           * Gets the label of a property with a given name.
           * @param sPropertyName The property name.
           * @returns The label maintained for this property or null if it does not exist.
          */
          getPropertyLabel(sPropertyName: string): string;

          /**
           * Gets the quick info of a property with a given name.
           * @param sPropertyName The property name.
           * @returns The quick info maintained for this property or null if it does not exist.
          */
          getPropertyQuickInfo(sPropertyName: string): string;

          /**
           * Gets the context for the root aggregation level representing the grand total for all bound measure
           * properties.The context is assigned to parent group ID <code>null</code>. If the binding is
           * configured not to provide a grand total,this context is empty. If data for this context is not
           * locally available yet, an OData request will be triggered to load it.This function must be called
           * whenever the bound set of OData entities changes, e.g., by changing selected dimensions,modifying
           * filter conditions, etc.
           * @param mParameters specifying how the top-most aggregation level shall be fetched. Supported
           * parameters are:<ul><li>numberOfExpandedLevels: number of child levels that shall be fetched
           * automatically</li><li>startIndex: index of first entry to return from parent group ID
           * <code>"/"</code> (zero-based)</li><li>length: number of entries to return at and after the given
           * start index</li><li>threshold: number of additional entries that shall be locally available in the
           * binding for subsequentaccesses to contexts of parent group ID <code>"/"</code> or below, if
           * auto-expanding is selected</li></ul>
           * @returns Array with a single object of class sap.ui.model.Context for the root context,           or
           * an empty array if an OData request is pending to fetch requested contexts that are not yet locally
           * available.
          */
          getRootContexts(mParameters: any): any[];

          /**
           * Gets the names of the sortable properties in the bound OData entity set.
           * @returns names of properties that can be used for sorting the result entities.
          */
          getSortablePropertyNames(): any[];

          /**
           * Gets the total number of entities in the bound OData entity set.Counting takes place at the lowest
           * aggregation level defined by the possible value combinations for the complete set ofdimension
           * properties included in the bound entity set. This means that intermediate aggregate entities
           * withsub-totals at higher aggregation levels are not counted.
           * @returns the total number of addressed entities in the OData entity set
          */
          getTotalSize(): number;

          /**
           * Determines if the binding has the entries of a given aggregation level locally available.If so, no
           * further OData request is required to fetch any of them.
           * @param oContext the parent context identifying the aggregation level.
           * @param iLevel the level number of oContext (because the context might occur at multiple levels).
           * @returns property of sap.ui.model.analytics.AnalyticalBinding.ContextsAvailabilityStatus,indicating
           * whether all, some, or none of the entries are locally available.
          */
          hasAvailableNodeContexts(oContext: sap.ui.model.Context, iLevel: number): boolean;

          /**
           * Determines if the contexts in a specified group have further children. If so,any of these group
           * contexts can be a parent context of a nested sub-group ina subsequent aggregation level.
           * @param oContext the parent context identifying the requested group of child contexts.
           * @param mParameters The only supported parameter is level as the level number of oContext (because
           * the context might occur at multiple levels)
           * @returns true if and only if the contexts in the specified group have further children.
          */
          hasChildren(oContext: sap.ui.model.Context, mParameters: any): boolean;

          /**
           * Determines if any of the properties included in the bound OData entity set is a measure property.
           * @returns true if and only one or more properties are measure properties.
          */
          hasMeasures(): boolean;

          /**
           * Determines if a given name refers to a measure property
           * @param sPropertyName The property name.
           * @returns true if and only if the bound OData entity set includes a measure property with this name.
          */
          isMeasure(sPropertyName: string): boolean;

          /**
           * Loads child contexts of multiple groups.
           * @param mGroupIdRanges specifies index ranges of child contexts to be loaded for multiple groups
           * identified by their ID. A group index range is           given by an object consisting of
           * startIndex, length, threshold. For every group ID, the map holds an array of such range objects.
          */
          loadGroups(mGroupIdRanges: any): void;

          /**
           * Determines if the binding has been configured to provide a grand total for the selected measure
           * properties.
           * @returns true if and only if the binding provides a context for the grand totals of all selected
           * measure properties.
          */
          providesGrandTotal(): boolean;

          /**
           * Refreshes the binding, check whether the model data has been changed and fire change event if this
           * is the case. For service side models this should refetchthe data from the service. To update a
           * control, even if no data has been changed, e.g. to reset a control after failed validation, please
           * use the parameterbForceUpdate.
           * @param bForceUpdate Update the bound control even if no data has been changed
          */
          refresh(sGroupIdOrForceUpdate: string | boolean): void;

          /**
           * Sets sorters for retrieving the entities in the bound OData entity set in a specific order.Invoking
           * this function resets the state of the binding. Subsequent data requests such as calls to
           * getNodeContexts() willneed to trigger OData requests in order to fetch the data that are in line
           * with these sorters.
           * @param aSorter an sorter object or an array of sorter objects which define the sort order.
           * @returns returns <code>this</code> to facilitate method chaining.
          */
          sort(aSorters: sap.ui.model.Sorter[] | sap.ui.model.Sorter): sap.ui.model.ListBinding | void;

          /**
           * Updates the binding's structure with new analytical information.Analytical information is the
           * mapping of UI columns to properties in the bound OData entity set. Every column object containsthe
           * name of the bound property and in addition:<ol>  <li>A column bound to a dimension property has
           * further boolean properties:    <ul>      <li>grouped: dimension will be used for building
           * groups</li>      <li>visible: if the column is visible, values for the related property will be
           * fetched from the OData service</li>      <li>inResult: if the column is not visible, but declared to
           * be part of the result, values for the related property      will also be fetched from the OData
           * service</li>    </ul>  </li>  <li>A column bound to a measure property has further boolean
           * properties:    <ul>      <li>total: totals and sub-totals will be provided for the measure at all
           * aggregation levels</li>    </ul>  </li></ol>Invoking this function resets the state of the binding
           * and subsequent data requests such as calls to getNodeContexts() willneed to trigger OData requests
           * in order to fetch the data that are in line with this analytical information.Please be aware that a
           * call of this function might lead to additional back-end requests, as well as a control re-rendering
           * later on.Whenever possible use the API of the analytical control, instead of relying on the binding.
           * @param aColumns an array with objects holding the analytical information for every column, from left
           * to right.
          */
          updateAnalyticalInfo(aColumns: any[]): void;
        }
        /**
         * Simple Response Collection Component, collects the responses for each sub-request inside a bigger
         * batch request.Also handles clean-up after all responses (either success or error) have been
         * collected.Instantiated in AnalyticalBinding.prototype._executeBatchRequest()
         * @resource sap/ui/model/analytics/BatchResponseCollector.js
        */
        export class BatchResponseCollector {


          /**
           * Constructor for a batch response collecting component.
           * @param mParams optional Setup-Parameter, @see BatchResponseCollector#setup
          */
          constructor(mParams: any);



          /**
           * Collects responses of type BatchResponseCollector.TYPE_SUCCESS and
           * BatchResponseCollector.TYPE_ERROR.Keeps track of all collected responses and fires the necessary
           * events after all responses for therequests, given in the constructor, have returned.
           * @param oResponse the response which should be collected
           * @param sResponseType the type of the response, either BatchResponseCollector.TYPE_SUCCESS									or
           * BatchResponseCollector.TYPE_ERROR
          */
          collect(oResponse: any, sResponseType?: string): void;

          /**
           * Convenience function to collect an error response.Internally BatchResponseCollector#collect is
           * called, the second parameter is set to BatchResponseCollector.TYPE_ERROR
           * @param oResponse the erroneous response object
          */
          error(oResponse: any): void;

          /**
           * Setup-Function to initialize/reset the BatchResponseCollector.
           * @param mParams optional Setup-Parameter
          */
          setup(mParams: any): void;

          /**
           * Convenience function to collect a success response.Internally BatchResponseCollector#collect is
           * called with second parameter BatchResponseCollector.TYPE_SUCCESS
           * @param oResponse the successful response, which should be collected
          */
          success(oResponse: any): void;
        }
        /**
         * @resource sap/ui/model/analytics/AnalyticalTreeBindingAdapter.js
        */
        export class AnalyticalTreeBindingAdapter {





          /**
           * Retrieves the currently set number of expanded levels from the Binding (commonly an
           * AnalyticalBinding).
           * @returns the number of expanded levels
          */
          getNumberOfExpandedLevels(): number;

          /**
           * Checks if the AnalyticalBinding has totaled measures available.Used for rendering sum rows.
           * @returns wether the binding has totaled measures or not
          */
          hasTotaledMeasures(): boolean;

          /**
           * Sets the number of expanded levels on the TreeBinding (commonly an AnalyticalBinding).This is NOT
           * the same as AnalyticalTreeBindingAdapter#collapse or AnalyticalTreeBindingAdapter#expand.Setting the
           * number of expanded levels leads to different requests.This function is used by the AnalyticalTable
           * for the ungroup/ungroup-all feature.
           * @param iLevels the number of levels which should be expanded, minimum is 0
          */
          setNumberOfExpandedLevels(iLevels: number): void;
        }
      }
      namespace FilterType {

        /**
         * Filters which are changed by the application
        */
        var Application: any;

        /**
         * Filters which are set by the different controls
        */
        var Control: any;
      }
      namespace BindingMode {

        /**
         * BindingMode default means that the binding mode of the model is used
        */
        var Default: any;

        /**
         * BindingMode one time means value is only read from the model once
        */
        var OneTime: any;

        /**
         * BindingMode one way means from model to view
        */
        var OneWay: any;

        /**
         * BindingMode two way means from model to view and vice versa
        */
        var TwoWay: any;
      }
      namespace ChangeReason {

        /**
         * A context was added to a binding.
        */
        var Add: any;

        /**
         * Binding changes a model property value
        */
        var Binding: any;

        /**
         * The list has changed
        */
        var Change: any;

        /**
         * The tree node was collapsed
        */
        var Collapse: any;

        /**
         * The list context has changed
        */
        var Context: any;

        /**
         * The tree node was expanded
        */
        var Expand: any;

        /**
         * The List was filtered
        */
        var Filter: any;

        /**
         * The list was refreshed
        */
        var Refresh: any;

        /**
         * The list was sorted
        */
        var Sort: any;
      }
      namespace FilterOperator {

        /**
         * FilterOperator between.When used on strings, the BT operator might not behave intuitively. For
         * example,when filtering a list of Names with BT "A", "B", all Names starting with "A" will beincluded
         * as well as the name "B" itself, but no other name starting with "B".
        */
        var BT: any;

        /**
         * FilterOperator contains
        */
        var Contains: any;

        /**
         * FilterOperator ends with
        */
        var EndsWith: any;

        /**
         * FilterOperator equals
        */
        var EQ: any;

        /**
         * FilterOperator greater or equals
        */
        var GE: any;

        /**
         * FilterOperator greater than
        */
        var GT: any;

        /**
         * FilterOperator less or equals
        */
        var LE: any;

        /**
         * FilterOperator less than
        */
        var LT: any;

        /**
         * FilterOperator not equals
        */
        var NE: any;

        /**
         * FilterOperator starts with
        */
        var StartsWith: any;
      }
      namespace TreeBindingUtils {

        /**
         * Merges together oNewSection into a set of other sections (aSections)The array/objects are not
         * modified, the function returns a new section array.
         * @param aSections the sections into which oNewSection will be merged
         * @param oNewSection the section which should be merged into aNewSections
         * @returns a new array containing all sections from aSections merged with oNewSection
        */
        function mergeSections(aSections: any[], oNewSection: any): any[];
      }
      /**
       * This is an abstract base class for type objects.
       * @resource sap/ui/model/Type.js
      */
      export abstract class Type extends sap.ui.base.Object {


        /**
         * Constructor for a new Type.
        */
        constructor();




        /**
         * Returns a metadata object for class sap.ui.model.Type.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Returns the name of this type.
         * @returns the name of this type
        */
        getName(): String;
      }
      /**
       * This is an abstract base class for model objects.
       * @resource sap/ui/model/Model.js
      */
      export abstract class Model extends sap.ui.core.message.MessageProcessor {


        /**
         * Constructor for a new Model.Every Model is a MessageProcessor that is able to handle Messages with
         * the normal binding path syntax in the target.
        */
        constructor();



        /**
         * Attach event-handler <code>fnFunction</code> to the 'parseError' event of this
         * <code>sap.ui.model.Model</code>.<br/>
         * @param oData The object, that should be passed along with the event-object when firing the event.
         * @param fnFunction The function to call, when the event occurs. This function will be called on the  
         *         oListener-instance (if present) or in a 'static way'.
         * @param oListener Object on which to call the given function. If empty, the global context (window)
         * is used.
         * @returns <code>this</code> to allow method chaining
        */
        attachParseError(oData: any, fnFunction: any, oListener?: any): sap.ui.model.Model;

        /**
         * Attach event-handler <code>fnFunction</code> to the 'propertyChange' event of this
         * <code>sap.ui.model.Model</code>.
         * @param oData The object, that should be passed along with the event-object when firing the event.
         * @param fnFunction The function to call, when the event occurs. This function will be called on the  
         *         oListener-instance (if present) or in a 'static way'.
         * @param oListener Object on which to call the given function. If empty, the global context (window)
         * is used.
         * @returns <code>this</code> to allow method chaining
        */
        attachPropertyChange(oData: any, fnFunction: any, oListener?: any): sap.ui.model.Model;

        /**
         * Attach event-handler <code>fnFunction</code> to the 'requestCompleted' event of this
         * <code>sap.ui.model.Model</code>.
         * @param oData The object, that should be passed along with the event-object when firing the event.
         * @param fnFunction The function to call, when the event occurs. This function will be called on the  
         *         oListener-instance (if present) or in a 'static way'.
         * @param oListener Object on which to call the given function. If empty, the global context (window)
         * is used.
         * @returns <code>this</code> to allow method chaining
        */
        attachRequestCompleted(oData: any, fnFunction: any, oListener?: any): sap.ui.model.Model;

        /**
         * Attach event-handler <code>fnFunction</code> to the 'requestFailed' event of this
         * <code>sap.ui.model.Model</code>.<br/>
         * @param oData The object, that should be passed along with the event-object when firing the event.
         * @param fnFunction The function to call, when the event occurs. This function will be called on the  
         *         oListener-instance (if present) or in a 'static way'.
         * @param oListener Object on which to call the given function. If empty, this Model is used.
         * @returns <code>this</code> to allow method chaining
        */
        attachRequestFailed(oData: any, fnFunction: any, oListener?: any): sap.ui.model.Model;

        /**
         * Attach event-handler <code>fnFunction</code> to the 'requestSent' event of this
         * <code>sap.ui.model.Model</code>.
         * @param oData The object, that should be passed along with the event-object when firing the event.
         * @param fnFunction The function to call, when the event occurs. This function will be called on the  
         *         oListener-instance (if present) or in a 'static way'.
         * @param oListener Object on which to call the given function. If empty, the global context (window)
         * is used.
         * @returns <code>this</code> to allow method chaining
        */
        attachRequestSent(oData: any, fnFunction: any, oListener?: any): sap.ui.model.Model;

        /**
         * Create ContextBinding
         * @param sPath the path pointing to the property that should be bound or an object        which
         * contains the following parameter properties: path, context, parameters
         * @param oContext the context object for this databinding (optional)
         * @param mParameters additional model specific parameters (optional)
         * @param oEvents event handlers can be passed to the binding ({change:myHandler})
        */
        bindContext(sPath: string | any, oContext?: any, mParameters?: any, oEvents?: any): sap.ui.model.ContextBinding;

        /**
         * Implement in inheriting classes
         * @param sPath the path pointing to the list / array that should be bound
         * @param oContext the context object for this databinding (optional)
         * @param aSorters initial sort order (can be either a sorter or an array of sorters) (optional)
         * @param aFilters predefined filter/s (can be either a filter or an array of filters) (optional)
         * @param mParameters additional model specific parameters (optional)
        */
        bindList(sPath: string, oContext?: sap.ui.model.Context, aSorters?: sap.ui.model.Sorter[], aFilters?: sap.ui.model.Filter[], mParameters?: any): sap.ui.model.ListBinding;

        /**
         * Implement in inheriting classes
         * @param sPath the path pointing to the property that should be bound
         * @param oContext the context object for this databinding (optional)
         * @param mParameters additional model specific parameters (optional)
        */
        bindProperty(sPath: string, oContext?: any, mParameters?: any): sap.ui.model.PropertyBinding;

        /**
         * Implement in inheriting classes
         * @param sPath the path pointing to the tree / array that should be bound
         * @param oContext the context object for this databinding (optional)
         * @param aFilters predefined filter/s contained in an array (optional)
         * @param mParameters additional model specific parameters (optional)
         * @param aSorters predefined sap.ui.model.sorter/s contained in an array (optional)
        */
        bindTree(sPath: string, oContext?: any, aFilters?: any[], mParameters?: any, aSorters?: any[]): sap.ui.model.TreeBinding;

        /**
         * Implement in inheriting classes
         * @param sPath the path to create the new context from
         * @param oContext the context which should be used to create the new binding context
         * @param mParameters the parameters used to create the new binding context
         * @param fnCallBack the function which should be called after the binding context has been created
         * @param bReload force reload even if data is already available. For server side models this should   
         *               refetch the data from the server
         * @returns the binding context, if it could be created synchronously
        */
        createBindingContext(sPath: string, oContext?: any, mParameters?: any, fnCallBack?: any, bReload?: boolean): sap.ui.model.Context;

        /**
         * Destroys the model and clears the model data.A model implementation may override this function and
         * perform model specific cleanup tasks e.g.abort requests, prevent new requests, etc.
        */
        destroy(bSuppressInvalidate: boolean): void;

        /**
         * Implement in inheriting classes
         * @param oContext to destroy
        */
        destroyBindingContext(oContext: any): void;

        /**
         * Detach event-handler <code>fnFunction</code> from the 'parseError' event of this
         * <code>sap.ui.model.Model</code>.<br/>The passed function and listener object must match the ones
         * previously used for event registration.
         * @param fnFunction The function to call, when the event occurs.
         * @param oListener Object on which the given function had to be called.
         * @returns <code>this</code> to allow method chaining
        */
        detachParseError(fnFunction: any, oListener: any): sap.ui.model.Model;

        /**
         * Detach event-handler <code>fnFunction</code> from the 'propertyChange' event of this
         * <code>sap.ui.model.Model</code>.The passed function and listener object must match the ones
         * previously used for event registration.
         * @param fnFunction The function to call, when the event occurs.
         * @param oListener Object on which the given function had to be called.
         * @returns <code>this</code> to allow method chaining
        */
        detachPropertyChange(fnFunction: any, oListener: any): sap.ui.model.Model;

        /**
         * Detach event-handler <code>fnFunction</code> from the 'requestCompleted' event of this
         * <code>sap.ui.model.Model</code>.The passed function and listener object must match the ones
         * previously used for event registration.
         * @param fnFunction The function to call, when the event occurs.
         * @param oListener Object on which the given function had to be called.
         * @returns <code>this</code> to allow method chaining
        */
        detachRequestCompleted(fnFunction: any, oListener: any): sap.ui.model.Model;

        /**
         * Detach event-handler <code>fnFunction</code> from the 'requestFailed' event of this
         * <code>sap.ui.model.Model</code>.<br/>The passed function and listener object must match the ones
         * previously used for event registration.
         * @param fnFunction The function to call, when the event occurs.
         * @param oListener Object on which the given function had to be called.
         * @returns <code>this</code> to allow method chaining
        */
        detachRequestFailed(fnFunction: any, oListener: any): sap.ui.model.Model;

        /**
         * Detach event-handler <code>fnFunction</code> from the 'requestSent' event of this
         * <code>sap.ui.model.Model</code>.The passed function and listener object must match the ones
         * previously used for event registration.
         * @param fnFunction The function to call, when the event occurs.
         * @param oListener Object on which the given function had to be called.
         * @returns <code>this</code> to allow method chaining
        */
        detachRequestSent(fnFunction: any, oListener: any): sap.ui.model.Model;


        /**
         * Fire event parseError to attached listeners.
         * @param mArguments the arguments to pass along with the event.
         * @returns <code>this</code> to allow method chaining
        */
        fireParseError(mArguments: any): sap.ui.model.Model;

        /**
         * Fire event propertyChange to attached listeners.
         * @param mArguments the arguments to pass along with the event.
         * @returns <code>this</code> to allow method chaining
        */
        firePropertyChange(mArguments: any): sap.ui.model.Model;

        /**
         * Fire event requestCompleted to attached listeners.
         * @param mArguments the arguments to pass along with the event.
         * @returns <code>this</code> to allow method chaining
        */
        fireRequestCompleted(mArguments: any): sap.ui.model.Model;

        /**
         * Fire event requestFailed to attached listeners.
         * @param mArguments the arguments to pass along with the event.
         * @returns <code>this</code> to allow method chaining
        */
        fireRequestFailed(mArguments: any): sap.ui.model.Model;

        /**
         * Fire event requestSent to attached listeners.
         * @param mArguments the arguments to pass along with the event.
         * @returns <code>this</code> to allow method chaining
        */
        fireRequestSent(mArguments: any): sap.ui.model.Model;

        /**
         * Get the default binding mode for the model
         * @returns default binding mode of the model
        */
        getDefaultBindingMode(): typeof sap.ui.model.BindingMode;

        /**
         * Get messages for path
         * @param sPath The binding path
        */
        getMessagesByPath(sPath: string): void;

        /**
         * Returns a metadata object for class sap.ui.model.Model.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Returns the meta model associated with this model if it is available for the concretemodel type.
         * @returns The meta model or undefined if no meta model exists.
        */
        getMetaModel(): sap.ui.model.MetaModel;

        /**
         * Implement in inheriting classes
         * @param sPath the path to where to read the object
         * @param oContext the context with which the path should be resolved
         * @param mParameters additional model specific parameters
        */
        getObject(sPath: string, oContext?: any, mParameters?: any): void;

        /**
         * Returns the original value for the property with the given path and context.The original value is
         * the value that was last responded by a server if using a server model implementation.
         * @param sPath the path/name of the property
         * @param oContext the context if available to access the property value
         * @returns vValue the value of the property
        */
        getOriginalProperty(sPath: string, oContext?: any): any;

        /**
         * Implement in inheriting classes
         * @param sPath the path to where to read the attribute value
         * @param oContext the context with which the path should be resolved
        */
        getProperty(sPath: string, oContext?: any): void;

        /**
         * Check if the specified binding mode is supported by the model.
         * @param sMode the binding mode to check
        */
        isBindingModeSupported(sMode: typeof sap.ui.model.BindingMode): void;

        /**
         * Returns whether legacy path syntax is used
        */
        isLegacySyntax(): boolean;

        /**
         * Refresh the model.This will check all bindings for updated data and update the controls if data has
         * been changed.
         * @param bForceUpdate Update controls even if data has not been changed
        */
        refresh(sGroupIdOrForceUpdate: string | boolean): void;

        /**
         * Set the default binding mode for the model. If the default binding mode should be changed,this
         * method should be called directly after model instance creation and before any binding
         * creation.Otherwise it is not guaranteed that the existing bindings will be updated with the new
         * binding mode.
         * @param sMode the default binding mode to set for the model
         * @returns this pointer for chaining
        */
        setDefaultBindingMode(sMode: typeof sap.ui.model.BindingMode): sap.ui.model.Model;

        /**
         * Enables legacy path syntax handlingThis defines, whether relative bindings, which do not have a
         * definedbinding context, should be compatible to earlier releases which meansthey are resolved
         * relative to the root element or handled strict andstay unresolved until a binding context is set
         * @param bLegacySyntax the path syntax to use
        */
        setLegacySyntax(bLegacySyntax: boolean): void;

        /**
         * Sets messages
         * @param mMessages Messages for this model
        */
        setMessages(mMessages: any): void;

        /**
         * Set the maximum number of entries which are used for list bindings.
         * @param iSizeLimit collection size limit
        */
        setSizeLimit(iSizeLimit: number): void;
      }
      /**
       * Filter for the list binding.
       * @resource sap/ui/model/Filter.js
      */
      export class Filter extends sap.ui.base.Object {


        /**
         * Constructor for Filter.You either pass a single object literal with the filter parameters or use the
         * individual constructor arguments.No matter which variant is used, only certain combinations of
         * parameters are supported(the following list uses the names from the object literal):<ul><li>A
         * <code>path</code>, <code>operator</code> and one or two values (<code>value1</code>,
         * <code>value2</code>), depending on the operator</li><li>A <code>path</code> and a custom filter
         * function <code>test</code></li><li>An array of other filters named <code>filters</code> and a
         * Boolean flag <code>and</code> that specifies whether to combine    the filters with an AND
         * (<code>true</code>) or an OR (<code>false</code>) operator.</li></ul>An error will be logged to the
         * console if an invalid combination of parameters is provided.Please note that a model implementation
         * may not support a custom filter function, e.g. if the model does not perform client side
         * filtering.It also depends on the model implementation if the filtering is case sensitive or not.See
         * particular model documentation for details.
         * @param vFilterInfo Filter info object or a path or an array of filters
         * @param vOperator Either a filter operator or a custom filter function or a Boolean flag that defines
         * how to combine multiple filters
         * @param oValue1 First value to use with the given filter operator
         * @param oValue2 Second value to use with the given filter operator (only for some operators)
        */
        constructor(vFilterInfo: any | string | sap.ui.model.Filter[], vOperator?: typeof sap.ui.model.FilterOperator | any | boolean, oValue1?: any, oValue2?: any);




        /**
         * Returns a metadata object for class sap.ui.model.Filter.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;
      }
      /**
       * Sorter for the list bindingThis object defines the sort order for the list binding.
       * @resource sap/ui/model/Sorter.js
      */
      export class Sorter extends sap.ui.base.Object {


        /**
         * Constructor for Sorter
         * @param sPath the binding path used for sorting
         * @param bDescending whether the sort order should be descending
         * @param vGroup configure grouping of the content, can either be true to enable grouping       based
         * on the raw model property value, or a function which calculates the group value out of the      
         * context (e.g. oContext.getProperty("date").getYear() for year grouping). The control needs to      
         * implement the grouping behaviour for the aggregation which you want to group. In case a function    
         *   is provided it must either return a primitive type value as the group key or an object containing 
         *      a "key" property an may contain additional properties needed for group visualization.
         * @param fnComparator a custom comparator function, which is used for clientside sorting instead      
         * of the default comparator method.
        */
        constructor(sPath: String, bDescending?: boolean, vGroup?: boolean | any, fnComparator?: any);



        /**
         * Compares two valuesThis is the default comparator function used for clientside sorting, if no custom
         * comparator is given in theconstructor. It does compare just by using equal/less than/greater than
         * with automatic type casting, exceptfor null values, which are always last, and string values where
         * localeCompare is used.The comparator method returns -1, 0 or 1, depending on the order of the two
         * items and issuitable to be used as a comparator method for Array.sort.
         * @param a the first value to compare
         * @param b the second value to compare
         * @returns -1, 0 or 1 depending on the compare result
        */
        defaultComparator(a: any, b: any): number;


        /**
         * Returns a group object, at least containing a key property for group detection.May contain
         * additional properties as provided by a custom group function.
         * @param oContext the binding context
         * @returns An object containing a key property and optional custom properties
        */
        getGroup(oContext: sap.ui.model.Context): any;

        /**
         * Returns a metadata object for class sap.ui.model.Sorter.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;
      }
      /**
       * The Binding is the object, which holds the necessary information for a data binding,like the binding
       * path and the binding context, and acts like an interface to themodel for the control, so it is the
       * event provider for changes in the data modeland provides getters for accessing properties or lists.
       * @resource sap/ui/model/Binding.js
      */
      export abstract class Binding extends sap.ui.base.EventProvider {


        /**
         * Constructor for Binding class.
         * @param oModel the model
         * @param sPath the path
         * @param oContext the context object
         * @param mParameters undefined
        */
        constructor(oModel: sap.ui.model.Model, sPath: String, oContext: sap.ui.model.Context, mParameters?: any);



        /**
         * Attach event-handler <code>fnFunction</code> to the 'AggregatedDataStateChange' event of this
         * <code>sap.ui.model.Binding</code>.<br/>
         * @param fnFunction The function to call, when the event occurs.
         * @param oListener object on which to call the given function.
        */
        attachAggregatedDataStateChange(fnFunction: any, oListener?: any): void;

        /**
         * Attach event-handler <code>fnFunction</code> to the 'change' event of this
         * <code>sap.ui.model.Model</code>.<br/>
         * @param fnFunction The function to call, when the event occurs.
         * @param oListener object on which to call the given function.
        */
        attachChange(fnFunction: any, oListener?: any): void;

        /**
         * Attach event-handler <code>fnFunction</code> to the 'dataReceived' event of this
         * <code>sap.ui.model.Binding</code>.<br/>
         * @param fnFunction The function to call, when the event occurs.
         * @param oListener object on which to call the given function.
        */
        attachDataReceived(fnFunction: any, oListener?: any): void;

        /**
         * Attach event-handler <code>fnFunction</code> to the 'dataRequested' event of this
         * <code>sap.ui.model.Binding</code>.<br/>
         * @param fnFunction The function to call, when the event occurs.
         * @param oListener object on which to call the given function.
        */
        attachDataRequested(fnFunction: any, oListener?: any): void;

        /**
         * Attach event-handler <code>fnFunction</code> to the 'DataStateChange' event of this
         * <code>sap.ui.model.Binding</code>.<br/>
         * @param fnFunction The function to call, when the event occurs.
         * @param oListener object on which to call the given function.
        */
        attachDataStateChange(fnFunction: any, oListener?: any): void;

        /**
         * Attach multiple events.
         * @param oEvents undefined
        */
        attachEvents(oEvents: any): void;

        /**
         * Attach event-handler <code>fnFunction</code> to the 'refresh' event of this
         * <code>sap.ui.model.Binding</code>.<br/>
         * @param fnFunction The function to call, when the event occurs.
         * @param oListener object on which to call the given function.
        */
        attachRefresh(fnFunction: any, oListener?: any): void;

        /**
         * Removes all control messages for this binding from the MessageManager in addition to the standard
         * clean-up tasks.
        */
        destroy(bSuppressInvalidate: boolean): void;

        /**
         * Detach event-handler <code>fnFunction</code> from the 'AggregatedDataStateChange' event of this
         * <code>sap.ui.model.Binding</code>.<br/>
         * @param fnFunction The function to call, when the event occurs.
         * @param oListener object on which to call the given function.
        */
        detachAggregatedDataStateChange(fnFunction: any, oListener?: any): void;

        /**
         * Detach event-handler <code>fnFunction</code> from the 'change' event of this
         * <code>sap.ui.model.Model</code>.<br/>
         * @param fnFunction The function to call, when the event occurs.
         * @param oListener object on which to call the given function.
        */
        detachChange(fnFunction: any, oListener?: any): void;

        /**
         * Detach event-handler <code>fnFunction</code> from the 'dataReceived' event of this
         * <code>sap.ui.model.Binding</code>.<br/>
         * @param fnFunction The function to call, when the event occurs.
         * @param oListener object on which to call the given function.
        */
        detachDataReceived(fnFunction: any, oListener?: any): void;

        /**
         * Detach event-handler <code>fnFunction</code> from the 'dataRequested' event of this
         * <code>sap.ui.model.Binding</code>.<br/>
         * @param fnFunction The function to call, when the event occurs.
         * @param oListener object on which to call the given function.
        */
        detachDataRequested(fnFunction: any, oListener?: any): void;

        /**
         * Detach event-handler <code>fnFunction</code> from the 'DataStateChange' event of this
         * <code>sap.ui.model.Binding</code>.<br/>
         * @param fnFunction The function to call, when the event occurs.
         * @param oListener object on which to call the given function.
        */
        detachDataStateChange(fnFunction: any, oListener?: any): void;

        /**
         * Detach multiple events-
         * @param oEvents undefined
        */
        detachEvents(oEvents: any): void;

        /**
         * Detach event-handler <code>fnFunction</code> from the 'refresh' event of this
         * <code>sap.ui.model.Binding</code>.<br/>
         * @param fnFunction The function to call, when the event occurs.
         * @param oListener object on which to call the given function.
        */
        detachRefresh(fnFunction: any, oListener?: any): void;


        /**
         * Fire event dataReceived to attached listeners. This event may also be fired when an error occured.
         * @param mArguments the arguments to pass along with the event.
        */
        fireDataReceived(mArguments: any): void;

        /**
         * Fire event dataRequested to attached listeners.
         * @param mArguments the arguments to pass along with the event.
        */
        fireDataRequested(mArguments: any): void;

        /**
         * Returns a metadata object for class sap.ui.model.Binding.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Initialize the binding. The message should be called when creating a binding.The default
         * implementation calls checkUpdate(true).
        */
        initialize(): void;

        /**
         * Returns whether the binding is initial, which means it did not get an initial value yet
         * @returns whether binding is initial
        */
        isInitial(): boolean;

        /**
         * Returns whether the binding is relative, which means it did not start with a /
         * @returns whether binding is relative
        */
        isRelative(): boolean;

        /**
         * Returns true if the binding is suspended or false if not.
         * @returns whether binding is suspended
        */
        isSuspended(): boolean;

        /**
         * Refreshes the binding, check whether the model data has been changed and fire change eventif this is
         * the case. For server side models this should refetch the data from the server.To update a control,
         * even if no data has been changed, e.g. to reset a control after failedvalidation, please use the
         * parameter bForceUpdate.
         * @param bForceUpdate Update the bound control even if no data has been changed
        */
        refresh(sGroupIdOrForceUpdate: string | boolean): void;

        /**
         * Resumes the binding update. Change events will be fired again.When the binding is resumed, a change
         * event will be fired immediately, if the data has changed while the bindingwas suspended. For
         * serverside models, a request to the server will be triggered, if a refresh was requestedwhile the
         * binding was suspended.
        */
        resume(): void;

        /**
         * Suspends the binding update. No change events will be fired.A refresh call with bForceUpdate set to
         * true will also update the binding and fire a change in suspended mode.Special operations on
         * bindings, which require updates to work properly (as paging or filtering in list bindings)will also
         * update and cause a change event although the binding is suspended.
        */
        suspend(): void;

        /**
         * Determines if the binding should be updated by comparing the current model against a specified
         * model.
         * @param oModel The model instance to compare against
         * @returns true if this binding should be updated
        */
        updateRequired(oModel: any): boolean;
      }
      /**
       * The Context is a pointer to an object in the model data, which is used toallow definition of
       * relative bindings, which are resolved relative to thedefined object.Context elements are created
       * either by the ListBinding for each list entryor by using createBindingContext.
       * @resource sap/ui/model/Context.js
      */
      export abstract class Context extends sap.ui.base.Object {


        /**
         * Constructor for Context class.
         * @param oModel the model
         * @param sPath the path
         * @param oContext the context object
        */
        constructor(oModel: sap.ui.model.Model, sPath: String, oContext: any);




        /**
         * Returns a metadata object for class sap.ui.model.Context.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Getter for model
         * @returns the model
        */
        getModel(): sap.ui.model.Model;

        /**
         * Gets the (model dependent) object the context points to or the object with the given relative
         * binding path
         * @param sPath the binding path
         * @param mParameters additional model specific parameters (optional)
         * @returns the context object
        */
        getObject(sPath: String, mParameters?: any): any;

        /**
         * Getter for path of the context itself or a subpath
         * @param sPath the binding path
         * @returns the binding path
        */
        getPath(sPath: String): String;

        /**
         * Gets the property with the given relative binding path
         * @param sPath the binding path
        */
        getProperty(sPath: String): any;
      }
      /**
       * Model implementation for meta models
       * @resource sap/ui/model/MetaModel.js
      */
      export abstract class MetaModel extends sap.ui.model.Model {


        /**
         * Constructor for a new MetaModel.
        */
        constructor();




        /**
         * Returns a metadata object for class sap.ui.model.MetaModel.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;
      }
      /**
       * Provides and update the status data of a binding.Depending on the models state and controls state
       * changes, the data state is used to propagated changes to a control.The control can react on these
       * changes by implementing the <code>refreshDataState</code> method for the control.Here the the data
       * state object is passed as a parameter.Using the {@link #getChanges getChanges} method the control
       * can determine the changed properties and their old and new value.<pre>    //sample implementation to
       * handle message changes    myControl.prototype.refreshDataState = function(oDataState) {       var
       * aMessages = oDataState.getChanges().messages;       if (aMessages) {           for (var i = 0; i
       * &lt; aMessages.length; i++) {               console.log(aMessages.message);           }       }    }
       *    //sample implementation to handle laundering state    myControl.prototype.refreshDataState =
       * function(oDataState) {       var bLaundering = oDataState.getChanges().laundering || false;      
       * this.setBusy(bLaundering);    }    //sample implementation to handle dirty state   
       * myControl.prototype.refreshDataState = function(oDataState) {       if (oDataState.isDirty())
       * console.log("Control " + this.getId() + " is now dirty");    }</pre>Using the {@link #getProperty
       * getProperty} method the control can read the properties of the data state. The properties are<ul>   
       * <li><code>value</code> The value formatted by the formatter of the binding   
       * <li><code>originalValue</code> The original value of the model formatted by the formatter of the
       * binding    <li><code>invalidValue</code> The control value that was tried to be applied to the model
       * but was rejected by a type validation    <li><code>modelMessages</code> The messages that were
       * applied to the binding by the <code>sap.ui.model.MessageModel</code>   
       * <li><code>controlMessages</code> The messages that were applied due to type validation errors   
       * <li><code>messages</code> All messages of the data state     <li><code>dirty</code> true if the
       * value was not yet confirmed by the server</ul>
       * @resource sap/ui/model/DataState.js
      */
      export class DataState extends sap.ui.base.Object {


        constructor();



        /**
         * Returns or sets whether the data state is changed.As long as changed was not set to false the data
         * state is dirtyand the corresponding binding will fire data state change events.
         * @param bNewState the optional new state
         * @returns whether the data state was changed.
        */
        changed(bNewState: boolean): boolean;


        /**
         * Returns the changes of the data state in a map that the control can use in
         * the<code>refreshDataState</code> method.The changed property's name is the key in the map. Each
         * element in the map contains an object of below structure.<pre>   {       oldValue : The old value of
         * the property,       value    : The new value of the property   }</pre>The map only contains the
         * changed properties.
         * @returns the changed of the data state
        */
        getChanges(): any;

        /**
         * Returns the array of state messages of the control or undefined.
         * @returns the array of messages of the control or null if no {link:sap.ui.core.messages.ModelManager
         * ModelManager} is used.
        */
        getControlMessages(the?: sap.ui.core.Message[]): sap.ui.model.DataState | sap.ui.core.Message[];

        /**
         * Returns the dirty value of a binding that was rejected by a type validation.This value was of an
         * incorrect type and could not be applied to the model. If thevalue was not rejected it will return
         * null. In this case the currentmodel value can be accessed using the <code>getValue</code> method.
         * @returns the value that was rejected or null
        */
        getInvalidValue(): any;

        /**
         * Returns the array of all state messages or null.This combines the model and control messages.
         * @returns the array of all messages or null if no {link:sap.ui.core.messages.ModelManager
         * ModelManager} is used.
        */
        getMessages(): sap.ui.core.Message[];

        /**
         * Returns a metadata object for class sap.ui.model.DataState.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Returns the array of state messages of the model or undefined
         * @returns the array of messages of the model or null if no {link:sap.ui.core.messages.ModelManager
         * ModelManager} is used.
        */
        getModelMessages(): sap.ui.core.Message[];

        /**
         * Returns the formatted original value of the data.The original value is the last confirmed value.
         * @returns the original confirmed value of the server
        */
        getOriginalValue(): any;

        /**
         * Returns the formatted value of the data state.
         * @returns The value of the data.
        */
        getValue(): any;

        /**
         * Returns whether the data state is dirty in the UI control.A data state is dirty in the UI control if
         * the entered value did not yet pass the type validation.
         * @returns true if the data state is dirty
        */
        isControlDirty(): boolean;

        /**
         * Returns whether the data state is dirty.A data state is dirty if the value was changedbut is not yet
         * confirmed by a server or the entered value did not yet pass the type validation.
         * @returns true if the data state is dirty
        */
        isDirty(): boolean;

        /**
         * Returns whether the data state is in laundering.If data is send to the server the data state becomes
         * laundering until thedata was accepted or rejected.
         * @returns true if the data is laundering
        */
        isLaundering(): boolean;

        /**
         * Sets an array of control state messages.
         * @param the control messages
         * @returns <code>this</code> to allow method chaining
        */
        setControlMessages(the: sap.ui.core.Message[]): sap.ui.model.DataState;

        /**
         * Sets the dirty value that was rejected by the type validation.
         * @param vInvalidValue the value that was rejected by the type validation or null if the value was
         * valid
         * @returns <code>this</code> to allow method chaining
        */
        setInvalidValue(vInvalidValue: any): sap.ui.model.DataState;

        /**
         * Sets the laundering state of the data state.
         * @param bLaundering true if the state is laundering
         * @returns <code>this</code> to allow method chaining
        */
        setLaundering(bLaundering: boolean): sap.ui.model.DataState;

        /**
         * Sets an array of model state messages.
         * @param the model messages for this data state.
         * @returns <code>this</code> to allow method chaining
        */
        setModelMessages(the: any[]): sap.ui.model.DataState;

        /**
         * Sets the formatted original value of the data.
         * @param vOriginalValue the original value
         * @returns <code>this</code> to allow method chaining
        */
        setOriginalValue(vOriginalValue: boolean): sap.ui.model.DataState;

        /**
         * Sets the formatted value of the data state,
         * @param vValue the value
         * @returns <code>this</code> to allow method chaining
        */
        setValue(vValue: any): sap.ui.model.DataState;
      }
      /**
       * This is an abstract base class for simple types.
       * @resource sap/ui/model/SimpleType.js
      */
      export abstract class SimpleType extends sap.ui.model.Type {


        /**
         * Constructor for a new SimpleType.
         * @param oFormatOptions options as provided by concrete subclasses
         * @param oConstraints constraints as supported by concrete subclasses
        */
        constructor(oFormatOptions: any, oConstraints?: any);




        /**
         * Format the given value in model representation to an output value in the giveninternal type. This
         * happens according to the format options, if target type is 'string'.If oValue is not defined or
         * null, null will be returned.
         * @param oValue the value to be formatted
         * @param sInternalType the target type
         * @returns the formatted output value
        */
        formatValue(oValue: any, sInternalType: string): any;

        /**
         * Returns a metadata object for class sap.ui.model.SimpleType.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Parse a value of an internal type to the expected value of the model type.
         * @param oValue the value to be parsed
         * @param sInternalType the source type
         * @returns the parse result
        */
        parseValue(oValue: any, sInternalType: string, aCurrentValues?: any[]): any;

        /**
         * Validate whether a given value in model representation is valid and meets thedefined constraints (if
         * any).
         * @param oValue the value to be validated
        */
        validateValue(oValue: any): void;
      }
      /**
       * The ListBinding is a specific binding for lists in the model, which can be usedto populate Tables or
       * ItemLists.
       * @resource sap/ui/model/ListBinding.js
      */
      export class ListBinding extends sap.ui.model.Binding {


        /**
         * Constructor for ListBinding
         * @param oModel undefined
         * @param sPath undefined
         * @param oContext undefined
         * @param aSorters initial sort order (can be either a sorter or an array of sorters)
         * @param aFilters predefined filter/s (can be either a filter or an array of filters)
         * @param mParameters undefined
        */
        constructor(oModel: sap.ui.model.Model, sPath: string, oContext: sap.ui.model.Context, aSorters?: any[], aFilters?: any[], mParameters?: any);



        /**
         * Attach event-handler <code>fnFunction</code> to the 'filter' event of this
         * <code>sap.ui.model.ListBinding</code>.<br/>
         * @param fnFunction The function to call, when the event occurs.
         * @param oListener object on which to call the given function.
        */
        attachFilter(fnFunction: any, oListener?: any): void;

        /**
         * Attach event-handler <code>fnFunction</code> to the 'sort' event of this
         * <code>sap.ui.model.ListBinding</code>.<br/>
         * @param fnFunction The function to call, when the event occurs.
         * @param oListener object on which to call the given function.
        */
        attachSort(fnFunction: any, oListener?: any): void;

        /**
         * Detach event-handler <code>fnFunction</code> from the 'filter' event of this
         * <code>sap.ui.model.ListBinding</code>.<br/>
         * @param fnFunction The function to call, when the event occurs.
         * @param oListener object on which to call the given function.
        */
        detachFilter(fnFunction: any, oListener?: any): void;

        /**
         * Detach event-handler <code>fnFunction</code> from the 'sort' event of this
         * <code>sap.ui.model.ListBinding</code>.<br/>
         * @param fnFunction The function to call, when the event occurs.
         * @param oListener object on which to call the given function.
        */
        detachSort(fnFunction: any, oListener?: any): void;


        /**
         * Filters the list according to the filter definitions
         * @param aFilters Array of filter objects
         * @param sFilterType Type of the filter which should be adjusted, if it is not given, the standard
         * behaviour applies
         * @returns returns <code>this</code> to facilitate method chaining
        */
        filter(aFilters: any[], sFilterType: typeof sap.ui.model.FilterType): sap.ui.model.ListBinding;

        /**
         * Returns an array of binding contexts for the bound target list.<strong>Note:</strong>The public
         * usage of this method is deprecated, as calls from outside of controls will leadto unexpected side
         * effects. For avoidance use {@link sap.ui.model.ListBinding.prototype.getCurrentContexts}instead.
         * @param iStartIndex the startIndex where to start the retrieval of contexts
         * @param iLength determines how many contexts to retrieve beginning from the start index.
         * @returns the array of contexts for each row of the bound list
        */
        getContexts(iStartIndex: number, iLength?: number): sap.ui.model.Context[];

        /**
         * Returns an array of currently used binding contexts of the bound controlThis method does not trigger
         * any data requests from the backend or delta calculation, but just returns the contextarray as last
         * requested by the control. This can be used by the application to get access to the data
         * currentlydisplayed by a list control.
         * @since 1.28
         * @returns the array of contexts for each row of the bound list
        */
        getCurrentContexts(): sap.ui.model.Context[];

        /**
         * Returns list of distinct values for the given relative binding path
         * @param sPath the relative binding path
         * @returns the array of distinct values.
        */
        getDistinctValues(sPath?: string): any[];

        /**
         * Gets the group for the given context.Must only be called if isGrouped() returns that grouping is
         * enabled for this binding. The grouping will beperformed using the first sorter (in case multiple
         * sorters are defined).
         * @param oContext the binding context
         * @returns the group object containing a key property and optional custom properties
        */
        getGroup(oContext: sap.ui.model.Context): any;

        /**
         * Returns the number of entries in the list. This might be an estimated or preliminary length, in
         * casethe full length is not known yet, see method isLengthFinal().
         * @since 1.24
         * @returns returns the number of entries in the list
        */
        getLength(): number;

        /**
         * Returns a metadata object for class sap.ui.model.ListBinding.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Indicates whether grouping is enabled for the binding.Grouping is enabled for a list binding, if at
         * least one sorter exists on the binding and the first sorteris a grouping sorter.
         * @returns whether grouping is enabled
        */
        isGrouped(): boolean;

        /**
         * Returns whether the length which can be retrieved using getLength() is a known, final length,or an
         * preliminary or estimated length which may change if further data is requested.
         * @since 1.24
         * @returns returns whether the length is final
        */
        isLengthFinal(): boolean;

        /**
         * Sorts the list according to the sorter object
         * @param aSorters the Sorter object or an array of sorters which defines the sort order
         * @returns returns <code>this</code> to facilitate method chaining
        */
        sort(aSorters: sap.ui.model.Sorter[] | sap.ui.model.Sorter): sap.ui.model.ListBinding | void;
      }
      /**
       * The TreeBinding is a specific binding for trees in the model, which can be usedto populate Trees.
       * @resource sap/ui/model/TreeBinding.js
      */
      export class TreeBinding extends sap.ui.model.Binding {


        /**
         * Constructor for TreeBinding
         * @param oModel undefined
         * @param sPath the path pointing to the tree / array that should be bound
         * @param oContext the context object for this databinding (optional)
         * @param aFilters predefined filter/s contained in an array (optional)
         * @param mParameters additional model specific parameters (optional)
         * @param aSorters predefined sap.ui.model.sorter/s contained in an array (optional)
        */
        constructor(oModel: sap.ui.model.Model, sPath: string, oContext?: any, aFilters?: any[], mParameters?: any, aSorters?: any[]);



        /**
         * Attach event-handler <code>fnFunction</code> to the '_filter' event of this
         * <code>sap.ui.model.TreeBinding</code>.<br/>
         * @param fnFunction The function to call, when the event occurs.
         * @param oListener object on which to call the given function.
        */
        attachFilter(fnFunction: any, oListener?: any): void;

        /**
         * Detach event-handler <code>fnFunction</code> from the '_filter' event of this
         * <code>sap.ui.model.TreeBinding</code>.<br/>
         * @param fnFunction The function to call, when the event occurs.
         * @param oListener object on which to call the given function.
        */
        detachFilter(fnFunction: any, oListener?: any): void;


        /**
         * Filters the tree according to the filter definitions.
         * @param aFilters Array of sap.ui.model.Filter objects
         * @param sFilterType Type of the filter which should be adjusted, if it is not given, the standard
         * behaviour applies
        */
        filter(aFilters: sap.ui.model.Filter[], sFilterType: typeof sap.ui.model.FilterType): void;

        /**
         * Returns the number of child nodes of a specific context
         * @param oContext the context element of the node
         * @returns the number of children
        */
        getChildCount(oContext: any): number;

        /**
         * Returns a metadata object for class sap.ui.model.TreeBinding.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Returns the current value of the bound target
         * @param oContext the context element of the node
         * @param iStartIndex the startIndex where to start the retrieval of contexts
         * @param iLength determines how many contexts to retrieve beginning from the start index.
         * @returns the array of child contexts for the given node
        */
        getNodeContexts(oContext: any, iStartIndex: number, iLength: number, iThreshold?: number): any[];

        /**
         * Returns the current value of the bound target
         * @param iStartIndex the startIndex where to start the retrieval of contexts
         * @param iLength determines how many contexts to retrieve beginning from the start index.
         * @returns the array of child contexts for the root node
        */
        getRootContexts(iStartIndex: number, iLength: number): any[];

        /**
         * Returns if the node has child nodes
         * @param oContext the context element of the node
         * @returns true if node has children
        */
        hasChildren(oContext: Context, mParameters?: any): boolean;

        /**
         * Sorts the tree according to the sorter definitions.
         * @param aSorters Array of sap.ui.model.Sorter objects
        */
        sort(aSorters: sap.ui.model.Sorter[] | sap.ui.model.Sorter): sap.ui.model.ListBinding | void;
      }
      /**
       * Model implementation for Client models
       * @resource sap/ui/model/ClientModel.js
      */
      export abstract class ClientModel extends sap.ui.model.Model {


        /**
         * Constructor for a new ClientModel.
         * @param oData URL where to load the data from
        */
        constructor(oData: any);



        /**
        */
        destroy(bSuppressInvalidate: boolean): void;


        /**
         * Force no caching.
         * @param bForceNoCache whether to force not to cache
        */
        forceNoCache(bForceNoCache: boolean): void;

        /**
         * Returns the current data of the model.Be aware that the returned object is a reference to the model
         * data so all changes to that data will also change the model data.
        */
        getData(): void;

        /**
         * Returns a metadata object for class sap.ui.model.ClientModel.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * update all bindings
         * @param bForceUpdate true/false: Default = false. If set to false an update					will only be done
         * when the value of a binding changed.
        */
        updateBindings(bForceUpdate: boolean): void;
      }
      /**
       * This is an abstract base class for composite types. Composite types have multiple input values and
       * knowhow to merge/split them upon formatting/parsing the value. Typical use case a currency or amount
       * values.Subclasses of CompositeTypes can define boolean properties in the constructor:-
       * bUseRawValues: the format and parse method will handle raw model values, types of embedded bindings
       * are ignored- bParseWithValues: the parse method call will include the current binding values as a
       * third parameter
       * @resource sap/ui/model/CompositeType.js
      */
      export abstract class CompositeType extends sap.ui.model.SimpleType {


        /**
         * Constructor for a new CompositeType.
         * @param oFormatOptions options as provided by concrete subclasses
         * @param oConstraints constraints as supported by concrete subclasses
        */
        constructor(oFormatOptions: any, oConstraints?: any);




        /**
         * Format the given set of values in model representation to an output value in the giveninternal type.
         * This happens according to the format options, if target type is 'string'.If aValues is not defined
         * or null, null will be returned.
         * @param aValues the values to be formatted
         * @param sInternalType the target type
         * @returns the formatted output value
        */
        formatValue(aValues: any[], sInternalType: string): any;

        /**
         * Returns a metadata object for class sap.ui.model.CompositeType.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Parse a value of an internal type to the expected set of values of the model type.
         * @param oValue the value to be parsed
         * @param sInternalType the source type
         * @param aCurrentValues the current values of all binding parts
         * @returns the parse result array
        */
        parseValue(oValue: any, sInternalType: string, aCurrentValues?: any[]): any;

        /**
         * Validate whether a given value in model representation is valid and meets thedefined constraints (if
         * any).
         * @param aValues the set of values to be validated
        */
        validateValue(aValues: any[]): void;
      }
      /**
       * @resource sap/ui/model/SelectionModel.js
      */
      export class SelectionModel extends sap.ui.base.EventProvider {

        /**
         * SelectionMode: Multi Selection
        */
        public MULTI_SELECTION: any;

        /**
         * SelectionMode: Single Selection
        */
        public SINGLE_SELECTION: any;


        /**
         * Constructs an instance of a sap.ui.model.SelectionModel.
         * @param iSelectionMode <code>sap.ui.model.SelectionModel.SINGLE_SELECTION</code> or
         * <code>sap.ui.model.SelectionModel.MULTI_SELECTION</code>
        */
        constructor(iSelectionMode: number);



        /**
         * Changes the selection to be the union of the current selectionand the range between
         * <code>iFromIndex</code> and <code>iToIndex</code> inclusive.If <code>iFromIndex</code> is smaller
         * than <code>iToIndex</code>, both parameters are swapped.In <code>SINGLE_SELECTION</code> selection
         * mode, this is equivalentto calling <code>setSelectionInterval</code>, and only the second indexis
         * used.If this call results in a change to the current selection or lead selection, then
         * a<code>SelectionChanged</code> event is fired.
         * @param iFromIndex one end of the interval.
         * @param iToIndex other end of the interval
         * @returns <code>this</code> to allow method chaining
        */
        addSelectionInterval(iFromIndex: number, iToIndex: number): sap.ui.model.SelectionModel;

        /**
         * Attach event-handler <code>fnFunction</code> to the 'selectionChanged' event of this
         * <code>sap.ui.model.SelectionModel</code>.<br/>
         * @param oData The object, that should be passed along with the event-object when firing the event.
         * @param fnFunction The function to call, when the event occurs. This function will be called on the  
         *         oListener-instance (if present) or in a 'static way'.
         * @param oListener Object on which to call the given function. If empty, this Model is used.
         * @returns <code>this</code> to allow method chaining
        */
        attachSelectionChanged(oData: any, fnFunction: any, oListener?: any): sap.ui.model.SelectionModel;

        /**
         * Change the selection to the empty set and clears the lead selection.If this call results in a change
         * to the current selection or lead selection, then a<code>SelectionChanged</code> event is fired.
         * @returns <code>this</code> to allow method chaining
        */
        clearSelection(): sap.ui.model.SelectionModel;

        /**
         * Detach event-handler <code>fnFunction</code> from the 'selectionChanged' event of this
         * <code>sap.ui.model.SelectionModel</code>.<br/>The passed function and listener object must match the
         * ones previously used for event registration.
         * @param fnFunction The function to call, when the event occurs.
         * @param oListener Object on which the given function had to be called.
         * @returns <code>this</code> to allow method chaining
        */
        detachSelectionChanged(fnFunction: any, oListener: any): sap.ui.model.SelectionModel;


        /**
         * Fire event 'selectionChanged' to attached listeners.Expects following event
         * parameters:<ul><li>'leadIndex' of type <code>int</code> Lead selection index.</li><li>'rowIndices'
         * of type <code>int[]</code> Other selected indices (if available)</li></ul>
         * @param mArguments the arguments to pass along with the event.
         * @returns <code>this</code> to allow method chaining
        */
        fireSelectionChanged(mArguments: any): sap.ui.model.SelectionModel;

        /**
         * Return the second index argument from the most recent call tosetSelectionInterval(),
         * addSelectionInterval() or removeSelectionInterval().
         * @returns lead selected index
        */
        getLeadSelectedIndex(): number;

        /**
         * Returns a metadata object for class sap.ui.model.SelectionModel.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Returns the selected indices as array.
         * @returns array of selected indices
        */
        getSelectedIndices(): number;

        /**
         * Returns the current selection mode.
         * @returns the current selection mode
        */
        getSelectionMode(): number;

        /**
         * Returns true if the specified index is selected.
         * @param iIndex undefined
         * @returns true if the specified index is selected.
        */
        isSelectedIndex(iIndex: number): boolean;

        /**
         * Moves all selected indices starting at the position <code>iStartIndex</code>
         * <code>iMove</code>items.This can be used if new items are inserted to the item set and you want to
         * keep the selection.To handle a deletion of items use <code>sliceSelectionInterval</code>.If this
         * call results in a change to the current selection or lead selection, then
         * a<code>SelectionChanged</code> event is fired.
         * @param iStartIndex start at this position
         * @param iMove undefined
         * @returns <code>this</code> to allow method chaining
        */
        moveSelectionInterval(iStartIndex: number, iMove: number): sap.ui.model.SelectionModel;

        /**
         * Changes the selection to be the set difference of the current selectionand the indices between
         * <code>iFromIndex</code> and <code>iToIndex</code> inclusive.If <code>iFromIndex</code> is smaller
         * than <code>iToIndex</code>, both parameters are swapped.If the range of removed selection indices
         * includes the current lead selection,then the lead selection will be unset (set to -1).If this call
         * results in a change to the current selection or lead selection, then a<code>SelectionChanged</code>
         * event is fired.
         * @param iFromIndex one end of the interval.
         * @param iToIndex other end of the interval
         * @returns <code>this</code> to allow method chaining
        */
        removeSelectionInterval(iFromIndex: number, iToIndex: number): sap.ui.model.SelectionModel;

        /**
         * Selects all rows up to the <code>iToIndex</iToIndex>.If this call results in a change to the current
         * selection, then a<code>SelectionChanged</code> event is fired.
         * @param iToIndex end of the interval
         * @returns <code>this</code> to allow method chaining
        */
        selectAll(iToIndex: number): sap.ui.model.SelectionModel;

        /**
         * Changes the selection to be equal to the range <code>iFromIndex</code> and
         * <code>iToIndex</code>inclusive. If <code>iFromIndex</code> is smaller than <code>iToIndex</code>,
         * both parameters are swapped.In <code>SINGLE_SELECTION</code> selection mode, only
         * <code>iToIndex</iToIndex> is used.If this call results in a change to the current selection, then
         * a<code>SelectionChanged</code> event is fired.
         * @param iFromIndex one end of the interval.
         * @param iToIndex other end of the interval
         * @returns <code>this</code> to allow method chaining
        */
        setSelectionInterval(iFromIndex: number, iToIndex: number): sap.ui.model.SelectionModel;

        /**
         * Sets the selection mode. The following list describes the acceptedselection
         * modes:<ul><li><code>sap.ui.model.SelectionModel.SINGLE_SELECTION</code> -  Only one list index can
         * be selected at a time. In this mode,  <code>setSelectionInterval</code> and
         * <code>addSelectionInterval</code> are  equivalent, both replacing the current selection with the
         * index  represented by the second argument (the
         * "lead").<li><code>sap.ui.model.SelectionModel.MULTI_SELECTION</code> -  In this mode, there's no
         * restriction on what can be selected.</ul>
         * @param iSelectionMode selection mode
        */
        setSelectionMode(iSelectionMode: number): void;

        /**
         * Slices a the indices between the two indices from the selection.If <code>iFromIndex</code> is
         * smaller than <code>iToIndex</code>, both parameters are swapped.If the range of removed selection
         * indices includes the current lead selection,then the lead selection will be unset (set to -1).If
         * this call results in a change to the current selection or lead selection, then
         * a<code>SelectionChanged</code> event is fired.
         * @param iFromIndex one end of the interval.
         * @param iToIndex other end of the interval
         * @returns <code>this</code> to allow method chaining
        */
        sliceSelectionInterval(iFromIndex: number, iToIndex: number): sap.ui.model.SelectionModel;
      }
      /**
       * The ContextBinding is a specific binding for a setting context for the model
       * @resource sap/ui/model/ContextBinding.js
      */
      export abstract class ContextBinding extends sap.ui.model.Binding {


        /**
         * Constructor for ContextBinding
         * @param oModel undefined
         * @param sPath undefined
         * @param oContext undefined
         * @param mParameters undefined
         * @param oEvents object defining event handlers
        */
        constructor(oModel: sap.ui.model.Model, sPath: String, oContext: any, mParameters?: any, oEvents?: any);




        /**
         * Returns a metadata object for class sap.ui.model.ContextBinding.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;
      }
      /**
       * The PropertyBinding is used to access single data values in the data model.
       * @resource sap/ui/model/PropertyBinding.js
      */
      export class PropertyBinding extends sap.ui.model.Binding {


        /**
         * Constructor for PropertyBinding
         * @param oModel undefined
         * @param sPath undefined
         * @param oContext undefined
         * @param mParameters undefined
        */
        constructor(oModel: sap.ui.model.Model, sPath: string, oContext: sap.ui.model.Context, mParameters?: any);




        /**
         * Returns the binding mode
         * @returns the binding mode
        */
        getBindingMode(): typeof sap.ui.model.BindingMode;

        /**
         * Returns the current external value of the bound target which is formatted via a type or formatter
         * function.
         * @returns the current value of the bound target
        */
        getExternalValue(): any;

        /**
         * Returns the formatter function
         * @returns the formatter function
        */
        getFormatter(): any;

        /**
         * Returns a metadata object for class sap.ui.model.PropertyBinding.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Returns the type if any for the binding.
         * @returns the binding type
        */
        getType(): sap.ui.model.Type;

        /**
         * Returns the current value of the bound target
         * @returns the current value of the bound target
        */
        getValue(): any;

        /**
         * Resumes the binding update. Change events will be fired again.When the binding is resumed and the
         * control value was changed in the meantime, the control value will be set to thecurrent value from
         * the model and a change event will be fired.
        */
        resume(): void;

        /**
         * Sets the binding mode
         * @param sBindingMode the binding mode
        */
        setBindingMode(sBindingMode: typeof sap.ui.model.BindingMode): void;

        /**
         * Sets the value for this binding. The value is parsed and validated against its type and then set to
         * the binding.A model implementation should check if the current default binding mode permitssetting
         * the binding value and if so set the new value also in the model.
         * @param oValue the value to set for this binding
        */
        setExternalValue(oValue: any): void;

        /**
         * Sets the optional formatter function for the binding.
         * @param fnFormatter the formatter function for the binding
        */
        setFormatter(fnFormatter: any): void;

        /**
         * Sets the optional type and internal type for the binding. The type and internal type are used to do
         * the parsing/formatting correctly.The internal type is the property type of the element which the
         * value is formatted to.
         * @param oType the type for the binding
         * @param sInternalType the internal type of the element property which this binding is bound against.
        */
        setType(oType: sap.ui.model.Type, sInternalType: String): void;

        /**
         * Sets the value for this binding. A model implementation should check if the current default binding
         * mode permitssetting the binding value and if so set the new value also in the model.
         * @param oValue the value to set for this binding
        */
        setValue(oValue: any): void;
      }
      /**
       * The CompositeBinding is used to bundle multiple property bindings which are be used to provide a
       * single binding againstthese property bindings.
       * @resource sap/ui/model/CompositeBinding.js
      */
      export class CompositeBinding extends sap.ui.model.PropertyBinding {


        /**
         * Constructor for CompositeBinding
        */
        constructor();



        /**
         * Attach event-handler <code>fnFunction</code> to the 'AggregatedDataStateChange' event of
         * this<code>sap.ui.model.CompositeBinding</code>. The CombinedDataStateChange event is fired
         * asynchronously, meaningthat the datastate object given as parameter of the event contains all
         * changes that were applied to the datastatein the running thread.
         * @param fnFunction The function to call, when the event occurs.
         * @param oListener object on which to call the given function.
        */
        attachAggregatedDataStateChange(fnFunction: any, oListener?: any): void;

        /**
         * Attach event-handler <code>fnFunction</code> to the '_change' event of this
         * <code>sap.ui.model.CompositeBinding</code>.<br/>
         * @param fnFunction The function to call, when the event occurs.
         * @param oListener object on which to call the given function.
        */
        attachChange(fnFunction: any, oListener?: any): void;

        /**
         * Attach event-handler <code>fnFunction</code> to the 'DataStateChange' event of this
         * <code>sap.ui.model.CompositeBinding</code>.<br/>
         * @param fnFunction The function to call, when the event occurs.
         * @param oListener object on which to call the given function.
        */
        attachDataStateChange(fnFunction: any, oListener?: any): void;

        /**
         * Detach event-handler <code>fnFunction</code> from the 'AggregatedDataStateChange' event of this
         * <code>sap.ui.model.CompositeBinding</code>.<br/>
         * @param fnFunction The function to call, when the event occurs.
         * @param oListener object on which to call the given function.
        */
        detachAggregatedDataStateChange(fnFunction: any, oListener?: any): void;

        /**
         * Detach event-handler <code>fnFunction</code> from the '_change' event of this
         * <code>sap.ui.model.CompositeBinding</code>.<br/>
         * @param fnFunction The function to call, when the event occurs.
         * @param oListener object on which to call the given function.
        */
        detachChange(fnFunction: any, oListener?: any): void;

        /**
         * Detach event-handler <code>fnFunction</code> from the 'DataStateChange' event of this
         * <code>sap.ui.model.CompositeBinding</code>.<br/>
         * @param fnFunction The function to call, when the event occurs.
         * @param oListener object on which to call the given function.
        */
        detachDataStateChange(fnFunction: any, oListener?: any): void;


        /**
         * Returns the property bindings contained in this composite binding.
         * @returns the property bindings in this composite binding
        */
        getBindings(): any[];

        /**
         * Returns the current external value of the bound target which is formatted via a type or formatter
         * function.
         * @returns the current value of the bound target
        */
        getExternalValue(): any;

        /**
         * Returns a metadata object for class sap.ui.model.CompositeBinding.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Returns the raw values of the property bindings in an array.
         * @returns the values of the internal property bindings in an array
        */
        getValue(): any;

        /**
         * Initialize the binding. The message should be called when creating a binding.The default
         * implementation calls checkUpdate(true).Prevent checkUpdate to be triggered while initializing
         * nestend bindings, it issufficient to call checkUpdate when all nested bindings are initialized.
        */
        initialize(): void;

        /**
         * Suspends the binding update. No change events will be fired.A refresh call with bForceUpdate set to
         * true will also update the binding and fire a change in suspended mode.Special operations on
         * bindings, which require updates to work properly (as paging or filtering in list bindings)will also
         * update and cause a change event although the binding is suspended.
        */
        resume(): void;

        /**
         * Sets the external value of a composite binding. If no CompositeType is assigned to the binding, the
         * defaultimplementation assumes a space separated list of values. This will cause the setValue to be
         * called for eachnested binding, except for undefined values in the array.
         * @param oValue the value to set for this binding
        */
        setExternalValue(oValue: any): void;

        /**
         * Sets the optional type and internal type for the binding. The type and internal type are used to do
         * the parsing/formatting correctly.The internal type is the property type of the element which the
         * value is formatted to.
         * @param oType the type for the binding
         * @param sInternalType the internal type of the element property which this binding is bound against.
        */
        setType(oType: sap.ui.model.CompositeType, sInternalType: String): void;

        /**
         * Sets the values. This will cause the setValue to be called for each nested binding, exceptfor
         * undefined values in the array.
         * @param aValues the values to set for this binding
        */
        setValue(aValues: any[]): void;

        /**
         * Suspends the binding update. No change events will be fired.A refresh call with bForceUpdate set to
         * true will also update the binding and fire a change in suspended mode.Special operations on
         * bindings, which require updates to work properly (as paging or filtering in list bindings)will also
         * update and cause a change event although the binding is suspended.
        */
        suspend(): void;

        /**
         * Determines if the property bindings in the composite binding should be updated by calling
         * updateRequired on all property bindings with the specified model.
         * @param oModel The model instance to compare against
         * @returns true if this binding should be updated
        */
        updateRequired(oModel: any): boolean;
      }
      /**
       * @resource sap/ui/model/TreeBindingAdapter.js
      */
      export class TreeBindingAdapter {





        /**
         * Calculate the request length based on the given information
         * @param iMaxGroupSize the maximum group size
         * @param oSection the information of the current section
        */
        _calculateRequestLength(iMaxGroupSize: number, oSection: any): void;

        /**
         * Attach event-handler <code>fnFunction</code> to the 'selectionChanged' event of this
         * <code>sap.ui.model.SelectionModel</code>.<br/>Event is fired if the selection of tree nodes is
         * changed in any way.
         * @param oData The object, that should be passed along with the event-object when firing the event.
         * @param fnFunction The function to call, when the event occurs. This function will be called on the  
         *         oListener-instance (if present) or in a 'static way'.
         * @param oListener Object on which to call the given function. If empty, this Model is used.
         * @returns <code>this</code> to allow method chaining
        */
        attachSelectionChanged(oData: any, fnFunction: any, oListener?: any): sap.ui.model.SelectionModel;

        /**
         * Detach event-handler <code>fnFunction</code> from the 'selectionChanged' event of this
         * <code>sap.ui.model.SelectionModel</code>.<br/>The passed function and listener object must match the
         * ones previously used for event registration.
         * @param fnFunction The function to call, when the event occurs.
         * @param oListener Object on which the given function had to be called.
         * @returns <code>this</code> to allow method chaining
        */
        detachSelectionChanged(fnFunction: any, oListener: any): sap.ui.model.SelectionModel;

        /**
         * Fire event 'selectionChanged' to attached listeners.Expects following event
         * parameters:<ul><li>'leadIndex' of type <code>int</code> Lead selection index.</li><li>'rowIndices'
         * of type <code>int[]</code> Other selected indices (if available)</li></ul>
         * @param mArguments the arguments to pass along with the event.
         * @returns <code>this</code> to allow method chaining
        */
        fireSelectionChanged(mArguments: any): sap.ui.model.SelectionModel;

        /**
         * Retrieves the requested part from the tree and returns node objects.
         * @param iStartIndex undefined
         * @param iLength undefined
         * @param iThreshold undefined
         * @returns Tree Node
        */
        getNodes(iStartIndex: any, iLength: any, iThreshold: any): any;
      }
      /**
       * Provides and update the status data of a binding.Depending on the models state and controls state
       * changes, the data state is used to propagated changes to a control.The control can react on these
       * changes by implementing the <code>refreshDataState</code> method for the control.Here the the data
       * state object is passed as a parameter.Using the {@link #getChanges getChanges} method the control
       * can determine the changed properties and their old and new value.<pre>    //sample implementation to
       * handle message changes    myControl.prototype.refreshDataState = function(oDataState) {       var
       * aMessages = oDataState.getChanges().messages;       if (aMessages) {           for (var i = 0; i
       * &lt; aMessages.length; i++) {               console.log(aMessages.message);           }       }    }
       *    //sample implementation to handle laundering state    myControl.prototype.refreshDataState =
       * function(oDataState) {       var bLaundering = oDataState.getChanges().laundering || false;      
       * this.setBusy(bLaundering);    }    //sample implementation to handle dirty state   
       * myControl.prototype.refreshDataState = function(oDataState) {       if (oDataState.isDirty())
       * console.log("Control " + this.getId() + " is now dirty");    }</pre>Using the {@link #getProperty
       * getProperty} method the control can read the properties of the data state. The properties are<ul>   
       * <li><code>value</code> The value formatted by the formatter of the binding   
       * <li><code>originalValue</code> The original value of the model formatted by the formatter of the
       * binding    <li><code>invalidValue</code> The control value that was tried to be applied to the model
       * but was rejected by a type validation    <li><code>modelMessages</code> The messages that were
       * applied to the binding by the <code>sap.ui.model.MessageModel</code>   
       * <li><code>controlMessages</code> The messages that were applied due to type validation errors   
       * <li><code>messages</code> All messages of the data state     <li><code>dirty</code> true if the
       * value was not yet confirmed by the server</ul>
       * @resource sap/ui/model/CompositeDataState.js
      */
      export class CompositeDataState extends sap.ui.model.DataState {


        constructor();



        /**
         * Returns or sets whether the data state is changed.As long as changed was not set to false the data
         * state is dirtyand the corresponding binding will fire data state change events.
         * @param bNewState the optional new state
         * @returns whether the data state was changed.
        */
        changed(bNewState: boolean): boolean;


        /**
         * Returns the changes of the data state in a map that the control can use in
         * the<code>refreshDataState</code> method.The changed property's name is the key in the map. Each
         * element in the map contains an object of below structure.<pre>   {       oldValue : The old value of
         * the property,       value    : The new value of the property   }</pre>The map only contains the
         * changed properties.
         * @returns the changed of the data state
        */
        getChanges(): any;

        /**
         * Sets an array of control state messages.
         * @param the control messages
         * @returns <code>this</code> to allow method chaining
        */
        getControlMessages(the?: sap.ui.core.Message[]): sap.ui.model.DataState | sap.ui.core.Message[];

        /**
         * Returns an array of the properties set on the inner datastates
        */
        getInternalProperty(): void;

        /**
         * Returns the dirty value of a binding that was rejected by a type validation.This value was of an
         * incorrect type and could not be applied to the model. If thevalue was not rejected it will return
         * null. In this case the currentmodel value can be accessed using the <code>getValue</code> method.
         * @returns the value that was rejected or null
        */
        getInvalidValue(): any;

        /**
         * Returns the array of all state messages or null.This combines the model and control messages.
         * @returns the array of all messages or null if no {link:sap.ui.core.messages.ModelManager
         * ModelManager} is used.
        */
        getMessages(): sap.ui.core.Message[];

        /**
         * Returns a metadata object for class sap.ui.model.CompositeDataState.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Returns the array of state messages of the model or undefined
         * @returns the array of messages of the model or null if no {link:sap.ui.core.messages.ModelManager
         * ModelManager} is used.
        */
        getModelMessages(): sap.ui.core.Message[];

        /**
         * Returns whether the data state is dirty in the UI control.A data state is dirty in the UI control if
         * the entered value did not yet pass the type validation.
         * @returns true if the data state is dirty
        */
        isControlDirty(): boolean;

        /**
         * Returns whether the data state is dirty.A data state is dirty if the value was changedbut is not yet
         * confirmed by a server or the entered value did not yet pass the type validation.
         * @returns true if the data state is dirty
        */
        isDirty(): boolean;

        /**
         * Returns whether the data state is in laundering.If data is send to the server the data state becomes
         * laundering until thedata was accepted or rejected.
         * @returns true if the data is laundering
        */
        isLaundering(): boolean;
      }
      /**
       * The ContextBinding is a specific binding for a setting context for the model
       * @resource sap/ui/model/ClientContextBinding.js
      */
      export abstract class ClientContextBinding extends sap.ui.model.ContextBinding {


        /**
         * Constructor for ClientContextBinding
         * @param oModel undefined
         * @param sPath undefined
         * @param oContext undefined
         * @param mParameters undefined
        */
        constructor(oModel: sap.ui.model.Model, sPath: String, oContext: any, mParameters?: any);




        /**
         * Returns a metadata object for class sap.ui.model.ClientContextBinding.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;
      }
      /**
       * @resource sap/ui/model/ClientTreeBindingAdapter.js
      */
      export class ClientTreeBindingAdapter {




      }
      /**
       * @resource sap/ui/model/TreeBindingCompatibilityAdapter.js
      */
      export class TreeBindingCompatibilityAdapter {




      }
    }
    namespace Device {
      namespace os {

        /**
         * If this flag is set to <code>true</code>, an Android operating system is used.
        */
        var android: boolean;

        /**
         * If this flag is set to <code>true</code>, a Blackberry operating system is used.
        */
        var blackberry: boolean;

        /**
         * If this flag is set to <code>true</code>, an iOS operating system is used.
        */
        var ios: boolean;

        /**
         * If this flag is set to <code>true</code>, a Linux operating system is used.
        */
        var linux: boolean;

        /**
         * If this flag is set to <code>true</code>, a Mac operating system is used.
        */
        var macintosh: boolean;

        /**
         * The name of the operating system.
        */
        var name: String;

        /**
         * The version of the operating system as <code>float</code>.Might be <code>-1</code> if no version can
         * be determined.
        */
        var version: number;

        /**
         * The version of the operating system as <code>string</code>.Might be empty if no version can be
         * determined.
        */
        var versionStr: String;

        /**
         * If this flag is set to <code>true</code>, a Windows operating system is used.
        */
        var windows: boolean;

        /**
         * If this flag is set to <code>true</code>, a Windows Phone operating system is used.
        */
        var windows_phone: boolean;
        namespace OS {

          /**
           * Android operating system name.
          */
          var ANDROID: any;

          /**
           * Blackberry operating system name.
          */
          var BLACKBERRY: any;

          /**
           * iOS operating system name.
          */
          var IOS: any;

          /**
           * Linux operating system name.
          */
          var LINUX: any;

          /**
           * MAC operating system name.
          */
          var MACINTOSH: any;

          /**
           * Windows operating system name.
          */
          var WINDOWS: any;

          /**
           * Windows Phone operating system name.
          */
          var WINDOWS_PHONE: any;
        }
      }
      namespace media {

        /**
         * Registers the given event handler to change events of the screen width based on the range set with
         * the specified name.The event is fired whenever the screen width changes and the current screen width
         * is ina different interval of the given range set than before the width change.The event handler is
         * called with a single argument: a map <code>mParams</code> which provides the following
         * informationabout the entered interval:<ul><li><code>mParams.from</code>: The start value (inclusive)
         * of the entered interval as a number</li><li><code>mParams.to</code>: The end value (exclusive) range
         * of the entered interval as a number or undefined for the last interval
         * (infinity)</li><li><code>mParams.unit</code>: The unit used for the values above, e.g.
         * <code>"px"</code></li><li><code>mParams.name</code>: The name of the entered interval, if
         * available</li></ul>
         * @param fnFunction The handler function to call when the event occurs. This function will be called
         * in the context of the                      <code>oListener</code> instance (if present) or on the
         * <code>window</code> instance. A map with information                      about the entered range
         * set is provided as a single argument to the handler (see details above).
         * @param oListener The object that wants to be notified when the event occurs (<code>this</code>
         * context within the                       handler function). If it is not specified, the handler
         * function is called in the context of the <code>window</code>.
         * @param sName The name of the range set to listen to. The range set must be initialized beforehand   
         *              ({@link sap.ui.Device.media.html#initRangeSet}). If no name is provided, the           
         *      {@link sap.ui.Device.media.RANGESETS.SAP_STANDARD default range set} is used.
        */
        function attachHandler(fnFunction: any, oListener: any, sName: String): void;

        /**
         * Removes a previously attached event handler from the change events of the screen width.The passed
         * parameters must match those used for registration with {@link #attachHandler} beforehand.
         * @param fnFunction The handler function to detach from the event
         * @param oListener The object that wanted to be notified when the event occurred
         * @param sName The name of the range set to listen to. If no name is provided, the                 
         * {@link sap.ui.Device.media.RANGESETS.SAP_STANDARD default range set} is used.
        */
        function detachHandler(fnFunction: any, oListener: any, sName: String): void;

        /**
         * Returns information about the current active range of the range set with the given name.
         * @param sName The name of the range set. The range set must be initialized beforehand ({@link
         * sap.ui.Device.media.html#initRangeSet})
         * @returns Information about the current active interval of the range set. The returned map has the
         * same structure as the argument of the event handlers ({link sap.ui.Device.media#attachHandler})
        */
        function getCurrentRange(sName: String): any;

        /**
         * Returns <code>true</code> if a range set with the given name is already initialized.
         * @param sName The name of the range set.
         * @returns Returns <code>true</code> if a range set with the given name is already initialized
        */
        function hasRangeSet(sName: String): boolean;

        /**
         * Initializes a screen width media query range set.This initialization step makes the range set ready
         * to be used for one of the other functions in namespace <code>sap.ui.Device.media</code>.The most
         * important {@link sap.ui.Device.media.RANGESETS predefined range sets} are initialized
         * automatically.To make a not yet initialized {@link sap.ui.Device.media.RANGESETS predefined range
         * set} ready to be used, call this function with thename of the range set to be
         * :<pre>sap.ui.Device.media.initRangeSet(sap.ui.Device.media.RANGESETS.SAP_3STEPS);</pre>Alternatively
         * it is possible to define custom range sets as shown in the following
         * example:<pre>sap.ui.Device.media.initRangeSet("MyRangeSet", [200, 400], "px", ["Small", "Medium",
         * "Large"]);</pre>This example defines the following named ranges:<ul><li><code>"Small"</code>: For
         * screens smaller than 200 pixels.</li><li><code>"Medium"</code>: For screens greater than or equal to
         * 200 pixels and smaller than 400 pixels.</li><li><code>"Large"</code>: For screens greater than or
         * equal to 400 pixels.</li></ul>The range names are optional. If they are specified a CSS class (e.g.
         * <code>sapUiMedia-MyRangeSet-Small</code>) is alsoadded to the document root depending on the current
         * active range. This can be suppressed via parameter <code>bSuppressClasses</code>.
         * @param sName The name of the range set to be initialized - either a {@link
         * sap.ui.Device.media.RANGESETS predefined} or custom one.                  The name must be a valid
         * id and consist only of letters and numeric digits.
         * @param aRangeBorders The range borders
         * @param sUnit The unit which should be used for the values given in <code>aRangeBorders</code>.      
         *              The allowed values are <code>"px"</code> (default), <code>"em"</code> or
         * <code>"rem"</code>
         * @param aRangeNames The names of the ranges. The names must be a valid id and consist only of letters
         * and digits. If names            are specified, CSS classes are also added to the document root as
         * described above. This behavior can be            switched off explicitly by using
         * <code>bSuppressClasses</code>. <b>Note:</b> <code>aRangeBorders</code> with <code>n</code> entries  
         *          define <code>n+1</code> ranges. Therefore <code>n+1</code> names must be provided.
         * @param bSuppressClasses Whether or not writing of CSS classes to the document root should be
         * suppressed when            <code>aRangeNames</code> are provided
        */
        function initRangeSet(sName: String, aRangeBorders?: number, sUnit?: String, aRangeNames?: String[], bSuppressClasses?: boolean): void;

        /**
         * Removes a previously initialized range set and detaches all registered handlers.Only custom range
         * sets can be removed via this function. Initialized predefined range sets({@link
         * sap.ui.Device.media#RANGESETS}) cannot be removed.
         * @param sName The name of the range set which should be removed.
        */
        function removeRangeSet(sName: String): void;
        namespace RANGESETS {

          /**
           * A 3-step range set (S-L).The ranges of this set are:<ul><li><code>"S"</code>: For screens smaller
           * than 520 pixels.</li><li><code>"M"</code>: For screens greater than or equal to 520 pixels and
           * smaller than 960 pixels.</li><li><code>"L"</code>: For screens greater than or equal to 960
           * pixels.</li></ul>To use this range set, you must initialize it explicitly ({@link
           * sap.ui.Device.media.html#initRangeSet}).If this range set is initialized, a CSS class is added to
           * the page root (<code>html</code> tag) which indicates the currentscreen width range:
           * <code>sapUiMedia-3Step-<i>NAME_OF_THE_INTERVAL</i></code>.
          */
          var SAP_3STEPS: any;

          /**
           * A 4-step range set (S-XL).The ranges of this set are:<ul><li><code>"S"</code>: For screens smaller
           * than 520 pixels.</li><li><code>"M"</code>: For screens greater than or equal to 520 pixels and
           * smaller than 760 pixels.</li><li><code>"L"</code>: For screens greater than or equal to 760 pixels
           * and smaller than 960 pixels.</li><li><code>"XL"</code>: For screens greater than or equal to 960
           * pixels.</li></ul>To use this range set, you must initialize it explicitly ({@link
           * sap.ui.Device.media.html#initRangeSet}).If this range set is initialized, a CSS class is added to
           * the page root (<code>html</code> tag) which indicates the currentscreen width range:
           * <code>sapUiMedia-4Step-<i>NAME_OF_THE_INTERVAL</i></code>.
          */
          var SAP_4STEPS: any;

          /**
           * A 6-step range set (XS-XXL).The ranges of this set are:<ul><li><code>"XS"</code>: For screens
           * smaller than 241 pixels.</li><li><code>"S"</code>: For screens greater than or equal to 241 pixels
           * and smaller than 400 pixels.</li><li><code>"M"</code>: For screens greater than or equal to 400
           * pixels and smaller than 541 pixels.</li><li><code>"L"</code>: For screens greater than or equal to
           * 541 pixels and smaller than 768 pixels.</li><li><code>"XL"</code>: For screens greater than or equal
           * to 768 pixels and smaller than 960 pixels.</li><li><code>"XXL"</code>: For screens greater than or
           * equal to 960 pixels.</li></ul>To use this range set, you must initialize it explicitly ({@link
           * sap.ui.Device.media.html#initRangeSet}).If this range set is initialized, a CSS class is added to
           * the page root (<code>html</code> tag) which indicates the currentscreen width range:
           * <code>sapUiMedia-6Step-<i>NAME_OF_THE_INTERVAL</i></code>.
          */
          var SAP_6STEPS: any;

          /**
           * A 3-step range set (Phone, Tablet, Desktop).The ranges of this set are:<ul><li><code>"Phone"</code>:
           * For screens smaller than 600 pixels.</li><li><code>"Tablet"</code>: For screens greater than or
           * equal to 600 pixels and smaller than 1024 pixels.</li><li><code>"Desktop"</code>: For screens
           * greater than or equal to 1024 pixels.</li></ul>This range set is initialized by default. An
           * initialization via {@link sap.ui.Device.media.html#initRangeSet} is not needed.A CSS class is added
           * to the page root (<code>html</code> tag) which indicates the currentscreen width range:
           * <code>sapUiMedia-Std-<i>NAME_OF_THE_INTERVAL</i></code>.Furthermore there are 5 additional CSS
           * classes to hide elements based on the width of the screen:<ul><li><code>sapUiHideOnPhone</code>:
           * Will be hidden if the screen has 600px or more</li><li><code>sapUiHideOnTablet</code>: Will be
           * hidden if the screen has less than 600px or more than
           * 1023px</li><li><code>sapUiHideOnDesktop</code>: Will be hidden if the screen is smaller than
           * 1024px</li><li><code>sapUiVisibleOnlyOnPhone</code>: Will be visible if the screen has less than
           * 600px</li><li><code>sapUiVisibleOnlyOnTablet</code>: Will be visible if the screen has 600px or more
           * but less than 1024px</li><li><code>sapUiVisibleOnlyOnDesktop</code>: Will be visible if the screen
           * has 1024px or more</li></ul>
          */
          var SAP_STANDARD: any;

          /**
           * A 4-step range set (Phone, Tablet, Desktop, LargeDesktop).The ranges of this set
           * are:<ul><li><code>"Phone"</code>: For screens smaller than 600
           * pixels.</li><li><code>"Tablet"</code>: For screens greater than or equal to 600 pixels and smaller
           * than 1024 pixels.</li><li><code>"Desktop"</code>: For screens greater than or equal to 1024 pixels
           * and smaller than 1440 pixels.</li><li><code>"LargeDesktop"</code>: For screens greater than or equal
           * to 1440 pixels.</li></ul>This range set is initialized by default. An initialization via {@link
           * sap.ui.Device.media.html#initRangeSet} is not needed.A CSS class is added to the page root
           * (<code>html</code> tag) which indicates the currentscreen width range:
           * <code>sapUiMedia-StdExt-<i>NAME_OF_THE_INTERVAL</i></code>.
          */
          var SAP_STANDARD_EXTENDED: any;
        }
      }
      namespace resize {

        /**
         * The current height of the document's window in pixels.
        */
        var height: number;

        /**
         * The current width of the document's window in pixels.
        */
        var width: number;

        /**
         * Registers the given event handler to resize change events of the document's window.The event is
         * fired whenever the document's window size changes.The event handler is called with a single
         * argument: a map <code>mParams</code> which provides the following
         * information:<ul><li><code>mParams.height</code>: The height of the document's window in
         * pixels.</li><li><code>mParams.width</code>: The width of the document's window in pixels.</li></ul>
         * @param fnFunction The handler function to call when the event occurs. This function will be called
         * in the context of the                      <code>oListener</code> instance (if present) or on the
         * <code>window</code> instance. A map with information                      about the size is provided
         * as a single argument to the handler (see details above).
         * @param oListener The object that wants to be notified when the event occurs (<code>this</code>
         * context within the                       handler function). If it is not specified, the handler
         * function is called in the context of the <code>window</code>.
        */
        function attachHandler(fnFunction: any, oListener?: any): void;

        /**
         * Removes a previously attached event handler from the resize events.The passed parameters must match
         * those used for registration with {@link #attachHandler} beforehand.
         * @param fnFunction The handler function to detach from the event
         * @param oListener The object that wanted to be notified when the event occurred
        */
        function detachHandler(fnFunction: any, oListener?: any): void;
      }
      namespace system {

        /**
         * If this flag is set to <code>true</code>, the device is recognized as a combination of a desktop
         * system and tablet.Furthermore, a CSS class <code>sap-combi</code> is added to the document root
         * element.<b>Note:</b> This property is mainly for Microsoft Windows 8 (and following) devices where
         * the mouse and touch event may be supportednatively by the browser being used. This property is set
         * to <code>true</code> only when both mouse and touch event are natively supported.
        */
        var combi: boolean;

        /**
         * If this flag is set to <code>true</code>, the device is recognized as a desktop system.Furthermore,
         * a CSS class <code>sap-desktop</code> is added to the document root element.
        */
        var desktop: boolean;

        /**
         * If this flag is set to <code>true</code>, the device is recognized as a phone.Furthermore, a CSS
         * class <code>sap-phone</code> is added to the document root element.
        */
        var phone: boolean;

        /**
         * If this flag is set to <code>true</code>, the device is recognized as a tablet.Furthermore, a CSS
         * class <code>sap-tablet</code> is added to the document root element.
        */
        var tablet: boolean;
      }
      namespace browser {

        /**
         * If this flag is set to <code>true</code>, the Google Chrome browser is used.
        */
        var chrome: boolean;

        /**
         * If this flag is set to <code>true</code>, the Microsoft Edge browser is used.
         * @since 1.30.0
        */
        var edge: boolean;

        /**
         * If this flag is set to <code>true</code>, the Mozilla Firefox browser is used.
        */
        var firefox: boolean;

        /**
         * If this flag is set to <code>true</code>, the Safari browser runs in standalone fullscreen mode on
         * iOS.<b>Note:</b> This flag is only available if the Safari browser was detected. Furthermore, if
         * this mode is detected,technically not a standard Safari is used. There might be slight differences
         * in behavior and detection, e.g.the availability of {@link sap.ui.Device.browser#version}.
         * @since 1.31.0
        */
        var fullscreen: boolean;

        /**
         * If this flag is set to <code>true</code>, the Microsoft Internet Explorer browser is used.
        */
        var internet_explorer: boolean;

        /**
         * If this flag is set to <code>true</code>, the mobile variant of the browser is used.<b>Note:</b>
         * This information might not be available for all browsers.
        */
        var mobile: boolean;

        /**
         * If this flag is set to <code>true</code>, a browser featuring a Mozilla engine is used.
         * @since 1.20.0
        */
        var mozilla: boolean;

        /**
         * If this flag is set to <code>true</code>, the Microsoft Internet Explorer browser is used.
         * @since 1.20.0
        */
        var msie: boolean;

        /**
         * The name of the browser.
        */
        var name: String;

        /**
         * If this flag is set to <code>true</code>, the Apple Safari browser is used.<b>Note:</b>This flag is
         * also <code>true</code> when the standalone (fullscreen) mode or webview is used on iOS
         * devices.Please also note the flags {@link sap.ui.Device.browser#fullscreen} and {@link
         * sap.ui.Device.browser#webview}.
        */
        var safari: boolean;

        /**
         * The version of the browser as <code>float</code>.Might be <code>-1</code> if no version can be
         * determined.
        */
        var version: number;

        /**
         * The version of the browser as <code>string</code>.Might be empty if no version can be determined.
        */
        var versionStr: String;

        /**
         * If this flag is set to <code>true</code>, a browser featuring a Webkit engine is used.
         * @since 1.20.0
        */
        var webkit: boolean;

        /**
         * If this flag is set to <code>true</code>, the Safari browser runs in webview mode on
         * iOS.<b>Note:</b> This flag is only available if the Safari browser was detected. Furthermore, if
         * this mode is detected,technically not a standard Safari is used. There might be slight differences
         * in behavior and detection, e.g.the availability of {@link sap.ui.Device.browser#version}.
         * @since 1.31.0
        */
        var webview: boolean;
        namespace BROWSER {

          /**
           * Android stock browser name.
          */
          var ANDROID: any;

          /**
           * Chrome browser name.
          */
          var CHROME: any;

          /**
           * Edge browser name.
           * @since 1.28.0
          */
          var EDGE: any;

          /**
           * Firefox browser name.
          */
          var FIREFOX: any;

          /**
           * Internet Explorer browser name.
          */
          var INTERNET_EXPLORER: any;

          /**
           * Safari browser name.
          */
          var SAFARI: any;
        }
      }
      namespace support {

        /**
         * If this flag is set to <code>true</code>, the used browser natively supports media queries via
         * JavaScript.<b>Note:</b> The {@link sap.ui.Device.media media queries API} of the device API can also
         * be used when there is no native support.
        */
        var matchmedia: boolean;

        /**
         * If this flag is set to <code>true</code>, the used browser natively supports events of media queries
         * via JavaScript.<b>Note:</b> The {@link sap.ui.Device.media media queries API} of the device API can
         * also be used when there is no native support.
        */
        var matchmedialistener: boolean;

        /**
         * If this flag is set to <code>true</code>, the used browser natively supports the
         * <code>orientationchange</code> event.<b>Note:</b> The {@link sap.ui.Device.orientation orientation
         * event} of the device API can also be used when there is no native support.
        */
        var orientation: boolean;

        /**
         * If this flag is set to <code>true</code>, the used browser supports pointer events.
        */
        var pointer: boolean;

        /**
         * If this flag is set to <code>true</code>, the device has a display with a high resolution.
        */
        var retina: boolean;

        /**
         * If this flag is set to <code>true</code>, the used browser supports touch events.<b>Note:</b> This
         * flag indicates whether the used browser supports touch events or not.This does not necessarily mean
         * that the used device has a touchable screen.
        */
        var touch: boolean;

        /**
         * If this flag is set to <code>true</code>, the used browser supports web sockets.
        */
        var websocket: boolean;
      }
      namespace orientation {

        /**
         * If this flag is set to <code>true</code>, the screen is currently in landscape mode (the width is
         * greater than the height).
        */
        var landscape: boolean;

        /**
         * If this flag is set to <code>true</code>, the screen is currently in portrait mode (the height is
         * greater than the width).
        */
        var portrait: boolean;

        /**
         * Registers the given event handler to orientation change events of the document's window.The event is
         * fired whenever the screen orientation changes and the width of the document's windowbecomes greater
         * than its height or the other way round.The event handler is called with a single argument: a map
         * <code>mParams</code> which provides the following
         * information:<ul><li><code>mParams.landscape</code>: If this flag is set to <code>true</code>, the
         * screen is currently in landscape mode, otherwise in portrait mode.</li></ul>
         * @param fnFunction The handler function to call when the event occurs. This function will be called
         * in the context of the                      <code>oListener</code> instance (if present) or on the
         * <code>window</code> instance. A map with information                      about the orientation is
         * provided as a single argument to the handler (see details above).
         * @param oListener The object that wants to be notified when the event occurs (<code>this</code>
         * context within the                       handler function). If it is not specified, the handler
         * function is called in the context of the <code>window</code>.
        */
        function attachHandler(fnFunction: any, oListener?: any): void;

        /**
         * Removes a previously attached event handler from the orientation change events.The passed parameters
         * must match those used for registration with {@link #attachHandler} beforehand.
         * @param fnFunction The handler function to detach from the event
         * @param oListener The object that wanted to be notified when the event occurred
        */
        function detachHandler(fnFunction: any, oListener?: any): void;
      }
    }
    namespace layout {
      namespace form {
        namespace GridElementCells {
        }
        /**
         * Form control.A <code>Form</code> is structured into <code>FormContainers</code>. Each
         * <code>FormContainer</code> consists of <code>FormElements</code>.The <code>FormElements</code>
         * consists of a label and the form fields.A <code>Form</code> doesn't render its content by itself.
         * The rendering is done by the assigned <code>FormLayout</code>.This is so that the rendering can be
         * adopted to new UI requirements without changing the Form itself.For the content of a
         * <code>Form</code>, <code>VariantLayoutData</code> are supported to allow simple switching of the
         * <code>FormLayout</code>.<code>LayoutData</code> on the content can be used to overwrite the default
         * layout of the code>Form</code>.<b>Note:</b> Do not put any layout controls into the
         * <code>FormElements</code>. This could destroy the visual layout,keyboard support and screen-reader
         * support.
         * @resource sap/ui/layout/form/Form.js
        */
        export class Form extends sap.ui.core.Control {


          /**
           * Constructor for a new sap.ui.layout.form.Form.Accepts an object literal <code>mSettings</code> that
           * defines initialproperty values, aggregated and associated objects as well as event handlers.See
           * {@link sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the
           * settings object.
           * @param sId id for the new control, generated automatically if no id is given
           * @param mSettings initial settings for the new control
          */
          constructor(sId: string, mSettings?: any);



          /**
           * Adds some ariaLabelledBy into the association <code>ariaLabelledBy</code>.
           * @since 1.28.0
           * @param vAriaLabelledBy the ariaLabelledBy to add; if empty, nothing is inserted
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          addAriaLabelledBy(vAriaLabelledBy: any | sap.ui.core.Control): sap.ui.layout.form.Form;

          /**
           * Adds some formContainer to the aggregation <code>formContainers</code>.
           * @param oFormContainer the formContainer to add; if empty, nothing is inserted
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          addFormContainer(oFormContainer: sap.ui.layout.form.FormContainer): sap.ui.layout.form.Form;

          /**
           * Destroys all the formContainers in the aggregation <code>formContainers</code>.
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          destroyFormContainers(): sap.ui.layout.form.Form;

          /**
           * Destroys the layout in the aggregation <code>layout</code>.
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          destroyLayout(): sap.ui.layout.form.Form;

          /**
           * Destroys the title in the aggregation <code>title</code>.
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          destroyTitle(): sap.ui.layout.form.Form;

          /**
           * Destroys the toolbar in the aggregation <code>toolbar</code>.
           * @since 1.36.0
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          destroyToolbar(): sap.ui.layout.form.Form;


          /**
           * Returns array of IDs of the elements which are the current targets of the association
           * <code>ariaLabelledBy</code>.
           * @since 1.28.0
          */
          getAriaLabelledBy(): any[];

          /**
           * Gets current value of property <code>editable</code>.Applies a device and theme specific line-height
           * to the form rows if the form has editable content.If set, all (not only the editable) rows of the
           * form will get the line height of editable fields.The accessibility aria-readonly attribute is set
           * according to this property.<b>Note:</b> The setting of the property has no influence on the editable
           * functionality of the form's content.Default value is <code>false</code>.
           * @since 1.20.0
           * @returns Value of property <code>editable</code>
          */
          getEditable(): boolean;

          /**
           * Gets content of aggregation <code>formContainers</code>.Containers with the content of the form. A
           * <code>FormContainer</code> represents a group inside the <code>Form</code>.
          */
          getFormContainers(): sap.ui.layout.form.FormContainer[];

          /**
           * Gets content of aggregation <code>layout</code>.Layout of the <code>Form</code>. The assigned
           * <code>Layout</code> renders the <code>Form</code>.We suggest using the
           * <code>ResponsiveGridLayout</code> for rendering a <code>Form</code>, as its responsiveness allows
           * the available space to be used in the best way possible.
          */
          getLayout(): sap.ui.layout.form.FormLayout;

          /**
           * Returns a metadata object for class sap.ui.layout.form.Form.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Gets content of aggregation <code>title</code>.Title of the <code>Form</code>. Can either be a
           * <code>Title</code> object, or a string.If a <code>Title</code> object it used, the style of the
           * title can be set.<b>Note:</b> If a <code>Toolbar</code> is used, the <code>Title</code> is ignored.
          */
          getTitle(): sap.ui.core.Title | string;

          /**
           * Gets content of aggregation <code>toolbar</code>.Toolbar of the <code>Form</code>.<b>Note:</b> If a
           * <code>Toolbar</code> is used, the <code>Title</code> is ignored.If a title is needed inside the
           * <code>Toolbar</code> it must be added at content to the <code>Toolbar</code>.In this case add the
           * <code>Title</code> to the <code>ariaLabelledBy</code> association.
           * @since 1.36.0
          */
          getToolbar(): sap.ui.core.Toolbar;

          /**
           * Gets current value of property <code>width</code>.Width of the <code>Form</code>.
           * @returns Value of property <code>width</code>
          */
          getWidth(): any;

          /**
           * Checks for the provided <code>sap.ui.layout.form.FormContainer</code> in the aggregation
           * <code>formContainers</code>.and returns its index if found or -1 otherwise.
           * @param oFormContainer The formContainer whose index is looked for
           * @returns The index of the provided control in the aggregation if found, or -1 otherwise
          */
          indexOfFormContainer(oFormContainer: sap.ui.layout.form.FormContainer): number;

          /**
           * Inserts a formContainer into the aggregation <code>formContainers</code>.
           * @param oFormContainer the formContainer to insert; if empty, nothing is inserted
           * @param iIndex the <code>0</code>-based index the formContainer should be inserted at; for           
           *  a negative value of <code>iIndex</code>, the formContainer is inserted at position 0; for a value  
           *           greater than the current size of the aggregation, the formContainer is inserted at        
           *     the last position
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          insertFormContainer(oFormContainer: sap.ui.layout.form.FormContainer, iIndex: number): sap.ui.layout.form.Form;

          /**
           * Removes all the controls in the association named <code>ariaLabelledBy</code>.
           * @since 1.28.0
           * @returns An array of the removed elements (might be empty)
          */
          removeAllAriaLabelledBy(): any[];

          /**
           * Removes all the controls from the aggregation <code>formContainers</code>.Additionally, it
           * unregisters them from the hosting UIArea.
           * @returns An array of the removed elements (might be empty)
          */
          removeAllFormContainers(): sap.ui.layout.form.FormContainer[];

          /**
           * Removes an ariaLabelledBy from the association named <code>ariaLabelledBy</code>.
           * @since 1.28.0
           * @param vAriaLabelledBy The ariaLabelledBy to be removed or its index or ID
           * @returns The removed ariaLabelledBy or <code>null</code>
          */
          removeAriaLabelledBy(vAriaLabelledBy: number | any | sap.ui.core.Control): any;

          /**
           * Removes a formContainer from the aggregation <code>formContainers</code>.
           * @param vFormContainer The formContainer to remove or its index or id
           * @returns The removed formContainer or <code>null</code>
          */
          removeFormContainer(vFormContainer: number | string | sap.ui.layout.form.FormContainer): sap.ui.layout.form.FormContainer;

          /**
           * Sets a new value for property <code>editable</code>.Applies a device and theme specific line-height
           * to the form rows if the form has editable content.If set, all (not only the editable) rows of the
           * form will get the line height of editable fields.The accessibility aria-readonly attribute is set
           * according to this property.<b>Note:</b> The setting of the property has no influence on the editable
           * functionality of the form's content.When called with a value of <code>null</code> or
           * <code>undefined</code>, the default value of the property will be restored.Default value is
           * <code>false</code>.
           * @since 1.20.0
           * @param bEditable New value for property <code>editable</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setEditable(bEditable: boolean): sap.ui.layout.form.Form;

          /**
           * Sets the aggregated <code>layout</code>.
           * @param oLayout The layout to set
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setLayout(oLayout: sap.ui.layout.form.FormLayout): sap.ui.layout.form.Form;

          /**
           * Sets the aggregated <code>title</code>.
           * @param vTitle The title to set
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setTitle(vTitle: sap.ui.core.Title | string): sap.ui.layout.form.Form;

          /**
           * Sets the aggregated <code>toolbar</code>.
           * @since 1.36.0
           * @param oToolbar The toolbar to set
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setToolbar(oToolbar: sap.ui.core.Toolbar): sap.ui.layout.form.Form;

          /**
           * Sets a new value for property <code>width</code>.Width of the <code>Form</code>.When called with a
           * value of <code>null</code> or <code>undefined</code>, the default value of the property will be
           * restored.
           * @param sWidth New value for property <code>width</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setWidth(sWidth: any): sap.ui.layout.form.Form;
        }
        /**
         * The <code>SimpleForm</code> provides an easy-to-use API to create simple forms.Inside a
         * <code>SimpleForm</code>, a <code>Form</code> control is created along with its
         * <code>FormContainers</code> and <code>FormElements</code>, but the complexity in the API is
         * removed.<ul><li>A new title starts a new group (<code>FormContainer</code>) in the form.</li><li>A
         * new label starts a new row (<code>FormElement</code>) in the form.</li><li>All other controls will
         * be assigned to the row (<code>FormElement</code>) started with the last label.</li></ul>Use
         * <code>LayoutData</code> to influence the layout for special cases in the Input/Display
         * controls.<b>Note:</b> If a more complex form is needed, use <code>Form</code> instead.
         * @resource sap/ui/layout/form/SimpleForm.js
        */
        export class SimpleForm extends sap.ui.core.Control {


          /**
           * Constructor for a new sap.ui.layout.form.SimpleForm.Accepts an object literal <code>mSettings</code>
           * that defines initialproperty values, aggregated and associated objects as well as event handlers.See
           * {@link sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the
           * settings object.
           * @param sId ID for the new control, generated automatically if no ID is given
           * @param mSettings Initial settings for the new control
          */
          constructor(sId: string, mSettings?: any);



          /**
           * Adds some ariaLabelledBy into the association <code>ariaLabelledBy</code>.
           * @since 1.32.0
           * @param vAriaLabelledBy the ariaLabelledBy to add; if empty, nothing is inserted
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          addAriaLabelledBy(vAriaLabelledBy: any | sap.ui.core.Control): sap.ui.layout.form.SimpleForm;

          /**
           * Adds some content to the aggregation <code>content</code>.
           * @param oContent the content to add; if empty, nothing is inserted
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          addContent(oContent: sap.ui.core.Element): sap.ui.layout.form.SimpleForm;

          /**
           * Destroys all the content in the aggregation <code>content</code>.
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          destroyContent(): sap.ui.layout.form.SimpleForm;

          /**
           * Destroys the title in the aggregation <code>title</code>.
           * @since 1.16.3
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          destroyTitle(): sap.ui.layout.form.SimpleForm;

          /**
           * Destroys the toolbar in the aggregation <code>toolbar</code>.
           * @since 1.36.0
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          destroyToolbar(): sap.ui.layout.form.SimpleForm;


          /**
           * Gets current value of property <code>adjustLabelSpan</code>.If set, the usage of
           * <code>labelSpanL</code> and <code>labelSpanM</code> are dependent on the number of
           * <code>FormContainers</code> in one row.If only one <code>FormContainer</code> is displayed in one
           * row, <code>labelSpanM</code> is used to define the size of the label.This is the same for medium and
           * large <code>Forms</code>.This is done to align the labels on forms where full-size
           * <code>FormContainers</code> and multiple-column rows are used in the same <code>Form</code>(because
           * every <code>FormContainer</code> has its own grid inside).If not set, the usage of
           * <code>labelSpanL</code> and <code>labelSpanM</code> are dependent on the <code>Form</code> size.The
           * number of <code>FormContainers</code> doesn't matter in this case.<b>Note:</b> This property is only
           * used if a <code>ResponsiveGridLayout</code> is used as a layout.Default value is <code>true</code>.
           * @since 1.34.0
           * @returns Value of property <code>adjustLabelSpan</code>
          */
          getAdjustLabelSpan(): boolean;

          /**
           * Returns array of IDs of the elements which are the current targets of the association
           * <code>ariaLabelledBy</code>.
           * @since 1.32.0
          */
          getAriaLabelledBy(): any[];

          /**
           * Gets current value of property <code>backgroundDesign</code>.Specifies the background color of the
           * <code>SimpleForm</code> content.The visualization of the different options depends on the used
           * theme.Default value is <code>Translucent</code>.
           * @since 1.36.0
           * @returns Value of property <code>backgroundDesign</code>
          */
          getBackgroundDesign(): sap.ui.layout.BackgroundDesign;

          /**
           * Gets current value of property <code>breakpointL</code>.Breakpoint between Medium size and Large
           * size.<b>Note:</b> This property is only used if a <code>ResponsiveGridLayout</code> is used as a
           * layout.Default value is <code>1024</code>.
           * @since 1.16.3
           * @returns Value of property <code>breakpointL</code>
          */
          getBreakpointL(): number;

          /**
           * Gets current value of property <code>breakpointM</code>.Breakpoint between Small size and Medium
           * size.<b>Note:</b> This property is only used if a <code>ResponsiveGridLayout</code> is used as a
           * layout.Default value is <code>600</code>.
           * @since 1.16.3
           * @returns Value of property <code>breakpointM</code>
          */
          getBreakpointM(): number;

          /**
           * Gets current value of property <code>breakpointXL</code>.Breakpoint between Medium size and Large
           * size.<b>Note:</b> This property is only used if a <code>ResponsiveGridLayout</code> is used as a
           * layout.Default value is <code>1440</code>.
           * @since 1.34.0
           * @returns Value of property <code>breakpointXL</code>
          */
          getBreakpointXL(): number;

          /**
           * Gets current value of property <code>columnsL</code>.Form columns for large size.The number of
           * columns for large size must not be smaller than the number of columns for medium size.<b>Note:</b>
           * This property is only used if a <code>ResponsiveGridLayout</code> is used as a layout.Default value
           * is <code>2</code>.
           * @since 1.16.3
           * @returns Value of property <code>columnsL</code>
          */
          getColumnsL(): number;

          /**
           * Gets current value of property <code>columnsM</code>.Form columns for medium size.<b>Note:</b> This
           * property is only used if a <code>ResponsiveGridLayout</code> is used as a layout.Default value is
           * <code>1</code>.
           * @since 1.16.3
           * @returns Value of property <code>columnsM</code>
          */
          getColumnsM(): number;

          /**
           * Gets current value of property <code>columnsXL</code>.Form columns for extra large size.The number
           * of columns for extra large size must not be smaller than the number of columns for large
           * size.<b>Note:</b> This property is only used if a <code>ResponsiveGridLayout</code> is used as a
           * layout.If the default value -1 is not overwritten with the meaningful one then the
           * <code>columnsL</code> value is used (from the backward compatibility reasons).Default value is
           * <code>-1</code>.
           * @since 1.34.0
           * @returns Value of property <code>columnsXL</code>
          */
          getColumnsXL(): number;

          /**
           * Gets content of aggregation <code>content</code>.The content of the form is structured in the
           * following way:<ul><li>Add a <code>Title</code> or <code>Toolbar</code> control to start a new group
           * (<code>FormContainer</code>).</li><li>Add a <code>Label</code> control to start a new row
           * (<code>FormElement</code>).</li><li>Add controls as input fields, text fields or other as
           * needed.</li><li>Use <code>LayoutData</code> to influence the layout for special cases in the single
           * controls.For example, if a <code>ResponsiveLayout</code> is used as a layout, the form content is
           * weighted using weight 3 for the labels and weight 5 for the fields part. By default the label column
           * is 192 pixels wide.If your input controls should influence their width, you can add
           * <code>sap.ui.layout.ResponsiveFlowLayoutData</code> to them via <code>setLayoutData</code>
           * method.Ensure that the sum of the weights in the <code>ResponsiveFlowLayoutData</code> is not more
           * than 5, as this is the total width of the input control part of each form row.</li></ul>Example for
           * a row where the <code>TextField</code> takes 4 and the <code>TextView</code> takes 1 weight (using
           * <code>ResponsiveLayout</code>):<pre>new sap.ui.commons.Label({text:"Label"});new
           * sap.ui.commons.TextField({value:"Weight 4",layoutData:new
           * sap.ui.layout.ResponsiveFlowLayoutData({weight:4})}),new sap.ui.commons.TextView({text:"Weight
           * 1",layoutData: new sap.ui.layout.ResponsiveFlowLayoutData({weight:1})}),</pre><b>Note:</b> Do not
           * put any layout controls in here. This could destroy the visual layout,keyboard support and
           * screen-reader support.
          */
          getContent(): sap.ui.core.Element[];

          /**
           * Gets current value of property <code>editable</code>.Applies a device-specific and theme-specific
           * line-height to the form rows if the form has editable content.If set, all (not only the editable)
           * rows of the form will get the line height of editable fields.The accessibility aria-readonly
           * attribute is set according to this property.<b>Note:</b> The setting of the property has no
           * influence on the editable functionality of the form's content.
           * @returns Value of property <code>editable</code>
          */
          getEditable(): boolean;

          /**
           * Gets current value of property <code>emptySpanL</code>.Number of grid cells that are empty at the
           * end of each line on large size.<b>Note:</b> This property is only used if a
           * <code>ResponsiveGridLayout</code> is used as a layout.Default value is <code>0</code>.
           * @since 1.16.3
           * @returns Value of property <code>emptySpanL</code>
          */
          getEmptySpanL(): number;

          /**
           * Gets current value of property <code>emptySpanM</code>.Number of grid cells that are empty at the
           * end of each line on medium size.<b>Note:</b> This property is only used if a
           * <code>ResponsiveGridLayout</code> is used as a layout.Default value is <code>0</code>.
           * @since 1.16.3
           * @returns Value of property <code>emptySpanM</code>
          */
          getEmptySpanM(): number;

          /**
           * Gets current value of property <code>emptySpanS</code>.Number of grid cells that are empty at the
           * end of each line on small size.<b>Note:</b> This property is only used if a
           * <code>ResponsiveGridLayout</code> is used as a layout.Default value is <code>0</code>.
           * @since 1.16.3
           * @returns Value of property <code>emptySpanS</code>
          */
          getEmptySpanS(): number;

          /**
           * Gets current value of property <code>emptySpanXL</code>.Number of grid cells that are empty at the
           * end of each line on extra large size.<b>Note:</b> This property is only used if a
           * <code>ResponsiveGridLayout</code> is used as a layout. If the default value -1 is not overwritten
           * with the meaningful one then the <code>emptySpanL</code> value is used (from the backward
           * compatibility reasons).Default value is <code>-1</code>.
           * @since 1.34.0
           * @returns Value of property <code>emptySpanXL</code>
          */
          getEmptySpanXL(): number;

          /**
           * Gets current value of property <code>labelMinWidth</code>.Specifies the min-width in pixels of the
           * label in all form containers.<b>Note:</b> This property is only used if a
           * <code>ResponsiveLayout</code> is used as a layout.Default value is <code>192</code>.
           * @returns Value of property <code>labelMinWidth</code>
          */
          getLabelMinWidth(): number;

          /**
           * Gets current value of property <code>labelSpanL</code>.Default span for labels in large
           * size.<b>Note:</b> If <code>adjustLabelSpanThis</code> is set, this property is only used if more
           * than 1 <code>FormContainer</code> is in one line. If only 1 <code>FormContainer</code> is in the
           * line, then the <code>labelSpanM</code> value is used.<b>Note:</b> This property is only used if a
           * <code>ResponsiveGridLayout</code> is used as a layout.Default value is <code>4</code>.
           * @since 1.16.3
           * @returns Value of property <code>labelSpanL</code>
          */
          getLabelSpanL(): number;

          /**
           * Gets current value of property <code>labelSpanM</code>.Default span for labels in medium
           * size.<b>Note:</b> If <code>adjustLabelSpanThis</code> is set, this property is used for full-size
           * <code>FormContainers</code>. If more than one <code>FormContainer</code> is in one line,
           * <code>labelSpanL</code> is used.<b>Note:</b> This property is only used if a
           * <code>ResponsiveGridLayout</code> is used as a layout.Default value is <code>2</code>.
           * @since 1.16.3
           * @returns Value of property <code>labelSpanM</code>
          */
          getLabelSpanM(): number;

          /**
           * Gets current value of property <code>labelSpanS</code>.Default span for labels in small
           * size.<b>Note:</b> This property is only used if a <code>ResponsiveGridLayout</code> is used as a
           * layout.Default value is <code>12</code>.
           * @since 1.16.3
           * @returns Value of property <code>labelSpanS</code>
          */
          getLabelSpanS(): number;

          /**
           * Gets current value of property <code>labelSpanXL</code>.Default span for labels in extra large
           * size.<b>Note:</b> This property is only used if a <code>ResponsiveGridLayout</code> is used as a
           * layout. If the default value -1 is not overwritten with the meaningful one then the
           * <code>labelSpanL</code> value is used (from the backward compatibility reasons).Default value is
           * <code>-1</code>.
           * @since 1.34.0
           * @returns Value of property <code>labelSpanXL</code>
          */
          getLabelSpanXL(): number;

          /**
           * Gets current value of property <code>layout</code>.The <code>FormLayout</code> that is used to
           * render the <code>SimpleForm</code>.We suggest using the <code>ResponsiveGridLayout</code> for
           * rendering a <code>SimpleForm</code>, as its responsiveness uses the space available in the best way
           * possible.Default value is <code>ResponsiveLayout</code>.
           * @returns Value of property <code>layout</code>
          */
          getLayout(): sap.ui.layout.form.SimpleFormLayout;

          /**
           * Gets current value of property <code>maxContainerCols</code>.The maximum amount of groups
           * (<code>FormContainers</code>) per row that is used before a new row is started.<b>Note:</b> If a
           * <code>ResponsiveGridLayout</code> is used as a layout, this property is not used. Please use the
           * properties <code>ColumnsL</code> and <code>ColumnsM</code> in this case.Default value is
           * <code>2</code>.
           * @returns Value of property <code>maxContainerCols</code>
          */
          getMaxContainerCols(): number;

          /**
           * Returns a metadata object for class sap.ui.layout.form.SimpleForm.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Gets current value of property <code>minWidth</code>.The overall minimum width in pixels that is
           * used for the <code>SimpleForm</code>. If the available width is below the given minWidth the
           * SimpleForm will create a new row for the next group (<code>FormContainer</code>).The default value
           * is -1, meaning that inner groups (<code>FormContainers</code>) will be stacked until maxCols is
           * reached, irrespective of whether a maxWidth is reached or the available parents width is
           * reached.<b>Note:</b> This property is only used if a <code>ResponsiveLayout</code> is used as a
           * layout.Default value is <code>-1</code>.
           * @returns Value of property <code>minWidth</code>
          */
          getMinWidth(): number;

          /**
           * Gets current value of property <code>singleContainerFullSize</code>.If the <code>Form</code>
           * contains only one single <code>FormContainer</code> and this property is set,the
           * <code>FormContainer</code> is displayed using the full size of the <code>Form</code>.In this case
           * the properties <code>columnsL</code> and <code>columnsM</code> are ignored.In all other cases the
           * <code>FormContainer</code> is displayed in the size of one column.<b>Note:</b> This property is only
           * used if a <code>ResponsiveGridLayout</code> is used as a layout.Default value is <code>true</code>.
           * @since 1.34.0
           * @returns Value of property <code>singleContainerFullSize</code>
          */
          getSingleContainerFullSize(): boolean;

          /**
           * Gets content of aggregation <code>title</code>.Title element of the <code>SimpleForm</code>. Can
           * either be a <code>Title</code> control, or a string.
           * @since 1.16.3
          */
          getTitle(): sap.ui.core.Title | string;

          /**
           * Gets content of aggregation <code>toolbar</code>.Toolbar of the <code>SimpleForm</code>.<b>Note:</b>
           * If a <code>Toolbar</code> is used, the <code>Title</code> is ignored.If a title is needed inside the
           * <code>Toolbar</code> it must be added at content to the <code>Toolbar</code>.In this case add the
           * <code>Title</code> to the <code>ariaLabelledBy</code> association.
           * @since 1.36.0
          */
          getToolbar(): sap.ui.core.Toolbar;

          /**
           * Gets current value of property <code>width</code>.Width of the form.
           * @since 1.28.0
           * @returns Value of property <code>width</code>
          */
          getWidth(): any;

          /**
           * Checks for the provided <code>sap.ui.core.Element</code> in the aggregation <code>content</code>.and
           * returns its index if found or -1 otherwise.
           * @param oContent The content whose index is looked for
           * @returns The index of the provided control in the aggregation if found, or -1 otherwise
          */
          indexOfContent(oContent: sap.ui.core.Element): number;

          /**
           * Inserts a content into the aggregation <code>content</code>.
           * @param oContent the content to insert; if empty, nothing is inserted
           * @param iIndex the <code>0</code>-based index the content should be inserted at; for             a
           * negative value of <code>iIndex</code>, the content is inserted at position 0; for a value           
           *  greater than the current size of the aggregation, the content is inserted at             the last
           * position
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          insertContent(oContent: sap.ui.core.Element, iIndex: number): sap.ui.layout.form.SimpleForm;

          /**
           * Removes all the controls in the association named <code>ariaLabelledBy</code>.
           * @since 1.32.0
           * @returns An array of the removed elements (might be empty)
          */
          removeAllAriaLabelledBy(): any[];

          /**
           * Removes all the controls from the aggregation <code>content</code>.Additionally, it unregisters them
           * from the hosting UIArea.
           * @returns An array of the removed elements (might be empty)
          */
          removeAllContent(): sap.ui.core.Element[];

          /**
           * Removes an ariaLabelledBy from the association named <code>ariaLabelledBy</code>.
           * @since 1.32.0
           * @param vAriaLabelledBy The ariaLabelledBy to be removed or its index or ID
           * @returns The removed ariaLabelledBy or <code>null</code>
          */
          removeAriaLabelledBy(vAriaLabelledBy: number | any | sap.ui.core.Control): any;

          /**
           * Removes a content from the aggregation <code>content</code>.
           * @param vContent The content to remove or its index or id
           * @returns The removed content or <code>null</code>
          */
          removeContent(vContent: number | string | sap.ui.core.Element): sap.ui.core.Element;

          /**
           * Sets a new value for property <code>adjustLabelSpan</code>.If set, the usage of
           * <code>labelSpanL</code> and <code>labelSpanM</code> are dependent on the number of
           * <code>FormContainers</code> in one row.If only one <code>FormContainer</code> is displayed in one
           * row, <code>labelSpanM</code> is used to define the size of the label.This is the same for medium and
           * large <code>Forms</code>.This is done to align the labels on forms where full-size
           * <code>FormContainers</code> and multiple-column rows are used in the same <code>Form</code>(because
           * every <code>FormContainer</code> has its own grid inside).If not set, the usage of
           * <code>labelSpanL</code> and <code>labelSpanM</code> are dependent on the <code>Form</code> size.The
           * number of <code>FormContainers</code> doesn't matter in this case.<b>Note:</b> This property is only
           * used if a <code>ResponsiveGridLayout</code> is used as a layout.When called with a value of
           * <code>null</code> or <code>undefined</code>, the default value of the property will be
           * restored.Default value is <code>true</code>.
           * @since 1.34.0
           * @param bAdjustLabelSpan New value for property <code>adjustLabelSpan</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setAdjustLabelSpan(bAdjustLabelSpan: boolean): sap.ui.layout.form.SimpleForm;

          /**
           * Sets a new value for property <code>backgroundDesign</code>.Specifies the background color of the
           * <code>SimpleForm</code> content.The visualization of the different options depends on the used
           * theme.When called with a value of <code>null</code> or <code>undefined</code>, the default value of
           * the property will be restored.Default value is <code>Translucent</code>.
           * @since 1.36.0
           * @param sBackgroundDesign New value for property <code>backgroundDesign</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setBackgroundDesign(sBackgroundDesign: sap.ui.layout.BackgroundDesign): sap.ui.layout.form.SimpleForm;

          /**
           * Sets a new value for property <code>breakpointL</code>.Breakpoint between Medium size and Large
           * size.<b>Note:</b> This property is only used if a <code>ResponsiveGridLayout</code> is used as a
           * layout.When called with a value of <code>null</code> or <code>undefined</code>, the default value of
           * the property will be restored.Default value is <code>1024</code>.
           * @since 1.16.3
           * @param iBreakpointL New value for property <code>breakpointL</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setBreakpointL(iBreakpointL: number): sap.ui.layout.form.SimpleForm;

          /**
           * Sets a new value for property <code>breakpointM</code>.Breakpoint between Small size and Medium
           * size.<b>Note:</b> This property is only used if a <code>ResponsiveGridLayout</code> is used as a
           * layout.When called with a value of <code>null</code> or <code>undefined</code>, the default value of
           * the property will be restored.Default value is <code>600</code>.
           * @since 1.16.3
           * @param iBreakpointM New value for property <code>breakpointM</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setBreakpointM(iBreakpointM: number): sap.ui.layout.form.SimpleForm;

          /**
           * Sets a new value for property <code>breakpointXL</code>.Breakpoint between Medium size and Large
           * size.<b>Note:</b> This property is only used if a <code>ResponsiveGridLayout</code> is used as a
           * layout.When called with a value of <code>null</code> or <code>undefined</code>, the default value of
           * the property will be restored.Default value is <code>1440</code>.
           * @since 1.34.0
           * @param iBreakpointXL New value for property <code>breakpointXL</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setBreakpointXL(iBreakpointXL: number): sap.ui.layout.form.SimpleForm;

          /**
           * Sets a new value for property <code>columnsL</code>.Form columns for large size.The number of
           * columns for large size must not be smaller than the number of columns for medium size.<b>Note:</b>
           * This property is only used if a <code>ResponsiveGridLayout</code> is used as a layout.When called
           * with a value of <code>null</code> or <code>undefined</code>, the default value of the property will
           * be restored.Default value is <code>2</code>.
           * @since 1.16.3
           * @param iColumnsL New value for property <code>columnsL</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setColumnsL(iColumnsL: number): sap.ui.layout.form.SimpleForm;

          /**
           * Sets a new value for property <code>columnsM</code>.Form columns for medium size.<b>Note:</b> This
           * property is only used if a <code>ResponsiveGridLayout</code> is used as a layout.When called with a
           * value of <code>null</code> or <code>undefined</code>, the default value of the property will be
           * restored.Default value is <code>1</code>.
           * @since 1.16.3
           * @param iColumnsM New value for property <code>columnsM</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setColumnsM(iColumnsM: number): sap.ui.layout.form.SimpleForm;

          /**
           * Sets a new value for property <code>columnsXL</code>.Form columns for extra large size.The number of
           * columns for extra large size must not be smaller than the number of columns for large
           * size.<b>Note:</b> This property is only used if a <code>ResponsiveGridLayout</code> is used as a
           * layout.If the default value -1 is not overwritten with the meaningful one then the
           * <code>columnsL</code> value is used (from the backward compatibility reasons).When called with a
           * value of <code>null</code> or <code>undefined</code>, the default value of the property will be
           * restored.Default value is <code>-1</code>.
           * @since 1.34.0
           * @param iColumnsXL New value for property <code>columnsXL</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setColumnsXL(iColumnsXL: number): sap.ui.layout.form.SimpleForm;

          /**
           * Sets a new value for property <code>editable</code>.Applies a device-specific and theme-specific
           * line-height to the form rows if the form has editable content.If set, all (not only the editable)
           * rows of the form will get the line height of editable fields.The accessibility aria-readonly
           * attribute is set according to this property.<b>Note:</b> The setting of the property has no
           * influence on the editable functionality of the form's content.When called with a value of
           * <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
           * @param bEditable New value for property <code>editable</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setEditable(bEditable: boolean): sap.ui.layout.form.SimpleForm;

          /**
           * Sets a new value for property <code>emptySpanL</code>.Number of grid cells that are empty at the end
           * of each line on large size.<b>Note:</b> This property is only used if a
           * <code>ResponsiveGridLayout</code> is used as a layout.When called with a value of <code>null</code>
           * or <code>undefined</code>, the default value of the property will be restored.Default value is
           * <code>0</code>.
           * @since 1.16.3
           * @param iEmptySpanL New value for property <code>emptySpanL</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setEmptySpanL(iEmptySpanL: number): sap.ui.layout.form.SimpleForm;

          /**
           * Sets a new value for property <code>emptySpanM</code>.Number of grid cells that are empty at the end
           * of each line on medium size.<b>Note:</b> This property is only used if a
           * <code>ResponsiveGridLayout</code> is used as a layout.When called with a value of <code>null</code>
           * or <code>undefined</code>, the default value of the property will be restored.Default value is
           * <code>0</code>.
           * @since 1.16.3
           * @param iEmptySpanM New value for property <code>emptySpanM</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setEmptySpanM(iEmptySpanM: number): sap.ui.layout.form.SimpleForm;

          /**
           * Sets a new value for property <code>emptySpanS</code>.Number of grid cells that are empty at the end
           * of each line on small size.<b>Note:</b> This property is only used if a
           * <code>ResponsiveGridLayout</code> is used as a layout.When called with a value of <code>null</code>
           * or <code>undefined</code>, the default value of the property will be restored.Default value is
           * <code>0</code>.
           * @since 1.16.3
           * @param iEmptySpanS New value for property <code>emptySpanS</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setEmptySpanS(iEmptySpanS: number): sap.ui.layout.form.SimpleForm;

          /**
           * Sets a new value for property <code>emptySpanXL</code>.Number of grid cells that are empty at the
           * end of each line on extra large size.<b>Note:</b> This property is only used if a
           * <code>ResponsiveGridLayout</code> is used as a layout. If the default value -1 is not overwritten
           * with the meaningful one then the <code>emptySpanL</code> value is used (from the backward
           * compatibility reasons).When called with a value of <code>null</code> or <code>undefined</code>, the
           * default value of the property will be restored.Default value is <code>-1</code>.
           * @since 1.34.0
           * @param iEmptySpanXL New value for property <code>emptySpanXL</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setEmptySpanXL(iEmptySpanXL: number): sap.ui.layout.form.SimpleForm;

          /**
           * Sets a new value for property <code>labelMinWidth</code>.Specifies the min-width in pixels of the
           * label in all form containers.<b>Note:</b> This property is only used if a
           * <code>ResponsiveLayout</code> is used as a layout.When called with a value of <code>null</code> or
           * <code>undefined</code>, the default value of the property will be restored.Default value is
           * <code>192</code>.
           * @param iLabelMinWidth New value for property <code>labelMinWidth</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setLabelMinWidth(iLabelMinWidth: number): sap.ui.layout.form.SimpleForm;

          /**
           * Sets a new value for property <code>labelSpanL</code>.Default span for labels in large
           * size.<b>Note:</b> If <code>adjustLabelSpanThis</code> is set, this property is only used if more
           * than 1 <code>FormContainer</code> is in one line. If only 1 <code>FormContainer</code> is in the
           * line, then the <code>labelSpanM</code> value is used.<b>Note:</b> This property is only used if a
           * <code>ResponsiveGridLayout</code> is used as a layout.When called with a value of <code>null</code>
           * or <code>undefined</code>, the default value of the property will be restored.Default value is
           * <code>4</code>.
           * @since 1.16.3
           * @param iLabelSpanL New value for property <code>labelSpanL</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setLabelSpanL(iLabelSpanL: number): sap.ui.layout.form.SimpleForm;

          /**
           * Sets a new value for property <code>labelSpanM</code>.Default span for labels in medium
           * size.<b>Note:</b> If <code>adjustLabelSpanThis</code> is set, this property is used for full-size
           * <code>FormContainers</code>. If more than one <code>FormContainer</code> is in one line,
           * <code>labelSpanL</code> is used.<b>Note:</b> This property is only used if a
           * <code>ResponsiveGridLayout</code> is used as a layout.When called with a value of <code>null</code>
           * or <code>undefined</code>, the default value of the property will be restored.Default value is
           * <code>2</code>.
           * @since 1.16.3
           * @param iLabelSpanM New value for property <code>labelSpanM</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setLabelSpanM(iLabelSpanM: number): sap.ui.layout.form.SimpleForm;

          /**
           * Sets a new value for property <code>labelSpanS</code>.Default span for labels in small
           * size.<b>Note:</b> This property is only used if a <code>ResponsiveGridLayout</code> is used as a
           * layout.When called with a value of <code>null</code> or <code>undefined</code>, the default value of
           * the property will be restored.Default value is <code>12</code>.
           * @since 1.16.3
           * @param iLabelSpanS New value for property <code>labelSpanS</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setLabelSpanS(iLabelSpanS: number): sap.ui.layout.form.SimpleForm;

          /**
           * Sets a new value for property <code>labelSpanXL</code>.Default span for labels in extra large
           * size.<b>Note:</b> This property is only used if a <code>ResponsiveGridLayout</code> is used as a
           * layout. If the default value -1 is not overwritten with the meaningful one then the
           * <code>labelSpanL</code> value is used (from the backward compatibility reasons).When called with a
           * value of <code>null</code> or <code>undefined</code>, the default value of the property will be
           * restored.Default value is <code>-1</code>.
           * @since 1.34.0
           * @param iLabelSpanXL New value for property <code>labelSpanXL</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setLabelSpanXL(iLabelSpanXL: number): sap.ui.layout.form.SimpleForm;

          /**
           * Sets a new value for property <code>layout</code>.The <code>FormLayout</code> that is used to render
           * the <code>SimpleForm</code>.We suggest using the <code>ResponsiveGridLayout</code> for rendering a
           * <code>SimpleForm</code>, as its responsiveness uses the space available in the best way
           * possible.When called with a value of <code>null</code> or <code>undefined</code>, the default value
           * of the property will be restored.Default value is <code>ResponsiveLayout</code>.
           * @param sLayout New value for property <code>layout</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setLayout(sLayout: sap.ui.layout.form.SimpleFormLayout): sap.ui.layout.form.SimpleForm;

          /**
           * Sets a new value for property <code>maxContainerCols</code>.The maximum amount of groups
           * (<code>FormContainers</code>) per row that is used before a new row is started.<b>Note:</b> If a
           * <code>ResponsiveGridLayout</code> is used as a layout, this property is not used. Please use the
           * properties <code>ColumnsL</code> and <code>ColumnsM</code> in this case.When called with a value of
           * <code>null</code> or <code>undefined</code>, the default value of the property will be
           * restored.Default value is <code>2</code>.
           * @param iMaxContainerCols New value for property <code>maxContainerCols</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setMaxContainerCols(iMaxContainerCols: number): sap.ui.layout.form.SimpleForm;

          /**
           * Sets a new value for property <code>minWidth</code>.The overall minimum width in pixels that is used
           * for the <code>SimpleForm</code>. If the available width is below the given minWidth the SimpleForm
           * will create a new row for the next group (<code>FormContainer</code>).The default value is -1,
           * meaning that inner groups (<code>FormContainers</code>) will be stacked until maxCols is reached,
           * irrespective of whether a maxWidth is reached or the available parents width is reached.<b>Note:</b>
           * This property is only used if a <code>ResponsiveLayout</code> is used as a layout.When called with a
           * value of <code>null</code> or <code>undefined</code>, the default value of the property will be
           * restored.Default value is <code>-1</code>.
           * @param iMinWidth New value for property <code>minWidth</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setMinWidth(iMinWidth: number): sap.ui.layout.form.SimpleForm;

          /**
           * Sets a new value for property <code>singleContainerFullSize</code>.If the <code>Form</code> contains
           * only one single <code>FormContainer</code> and this property is set,the <code>FormContainer</code>
           * is displayed using the full size of the <code>Form</code>.In this case the properties
           * <code>columnsL</code> and <code>columnsM</code> are ignored.In all other cases the
           * <code>FormContainer</code> is displayed in the size of one column.<b>Note:</b> This property is only
           * used if a <code>ResponsiveGridLayout</code> is used as a layout.When called with a value of
           * <code>null</code> or <code>undefined</code>, the default value of the property will be
           * restored.Default value is <code>true</code>.
           * @since 1.34.0
           * @param bSingleContainerFullSize New value for property <code>singleContainerFullSize</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setSingleContainerFullSize(bSingleContainerFullSize: boolean): sap.ui.layout.form.SimpleForm;

          /**
           * Sets the aggregated <code>title</code>.
           * @since 1.16.3
           * @param vTitle The title to set
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setTitle(vTitle: sap.ui.core.Title | string): sap.ui.layout.form.SimpleForm;

          /**
           * Sets the aggregated <code>toolbar</code>.
           * @since 1.36.0
           * @param oToolbar The toolbar to set
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setToolbar(oToolbar: sap.ui.core.Toolbar): sap.ui.layout.form.SimpleForm;

          /**
           * Sets a new value for property <code>width</code>.Width of the form.When called with a value of
           * <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
           * @since 1.28.0
           * @param sWidth New value for property <code>width</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setWidth(sWidth: any): sap.ui.layout.form.SimpleForm;
        }
        /**
         * Base layout to render a <code>Form</code>.Other layouts to render a <code>Form</code> must inherit
         * from this one.<b>Note:</b> This control must not be used to render a <code>Form</code> in productive
         * applications as it does not fulfill anydesign guidelines and usability standards.
         * @resource sap/ui/layout/form/FormLayout.js
        */
        export class FormLayout extends sap.ui.core.Control {


          /**
           * Constructor for a new sap.ui.layout.form.FormLayout.Accepts an object literal <code>mSettings</code>
           * that defines initialproperty values, aggregated and associated objects as well as event handlers.See
           * {@link sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the
           * settings object.
           * @param sId Id for the new control, generated automatically if no id is given
           * @param mSettings initial settings for the new control
          */
          constructor(sId: string, mSettings?: any);




          /**
           * Gets current value of property <code>backgroundDesign</code>.Specifies the background color of the
           * <code>Form</code> content.The visualization of the different options depends on the used
           * theme.Default value is <code>Translucent</code>.
           * @since 1.36.0
           * @returns Value of property <code>backgroundDesign</code>
          */
          getBackgroundDesign(): sap.ui.layout.BackgroundDesign;

          /**
           * Returns a metadata object for class sap.ui.layout.form.FormLayout.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Sets a new value for property <code>backgroundDesign</code>.Specifies the background color of the
           * <code>Form</code> content.The visualization of the different options depends on the used theme.When
           * called with a value of <code>null</code> or <code>undefined</code>, the default value of the
           * property will be restored.Default value is <code>Translucent</code>.
           * @since 1.36.0
           * @param sBackgroundDesign New value for property <code>backgroundDesign</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setBackgroundDesign(sBackgroundDesign: sap.ui.layout.BackgroundDesign): sap.ui.layout.form.FormLayout;
        }
        /**
         * This <code>FormLayout</code> renders a <code>Form</code> using a HTML-table based grid.This can be a
         * 16 column grid or an 8 column grid. The grid is stable, so the alignment of the fields is the same
         * for all screen sizes or widths of the <code>Form</code>.Only the width of the single grid columns
         * depends on the available width.To adjust the appearance inside the <code>GridLayout</code>, you can
         * use <code>GridContainerData</code> for <code>FormContainers</code>and <code>GridElementData</code>
         * for content fields.<b>Note:</b> If content fields have a <code>width</code> property this will be
         * ignored, as the width of the controls is set by the grid cells.This control cannot be used stand
         * alone, it only renders a <code>Form</code>, so it must be assigned to a <code>Form</code>.
         * @resource sap/ui/layout/form/GridLayout.js
        */
        export class GridLayout extends sap.ui.layout.form.FormLayout {


          /**
           * Constructor for a new sap.ui.layout.form.GridLayout.Accepts an object literal <code>mSettings</code>
           * that defines initialproperty values, aggregated and associated objects as well as event handlers.See
           * {@link sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the
           * settings object.
           * @param sId Id for the new control, generated automatically if no id is given
           * @param mSettings initial settings for the new control
          */
          constructor(sId: string, mSettings?: any);




          /**
           * Returns a metadata object for class sap.ui.layout.form.GridLayout.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Gets current value of property <code>singleColumn</code>.If set, the grid renders only one
           * <code>FormContainer</code> per column. That means one <code>FormContainer</code> is below the other.
           * The whole grid has 8 cells per row.If not set, <code>FormContainer</code> can use the full width of
           * the grid or two <code>FormContainers</code> can be placed beside each other. In this case the whole
           * grid has 16 cells per row.Default value is <code>false</code>.
           * @returns Value of property <code>singleColumn</code>
          */
          getSingleColumn(): boolean;

          /**
           * Sets a new value for property <code>singleColumn</code>.If set, the grid renders only one
           * <code>FormContainer</code> per column. That means one <code>FormContainer</code> is below the other.
           * The whole grid has 8 cells per row.If not set, <code>FormContainer</code> can use the full width of
           * the grid or two <code>FormContainers</code> can be placed beside each other. In this case the whole
           * grid has 16 cells per row.When called with a value of <code>null</code> or <code>undefined</code>,
           * the default value of the property will be restored.Default value is <code>false</code>.
           * @param bSingleColumn New value for property <code>singleColumn</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setSingleColumn(bSingleColumn: boolean): sap.ui.layout.form.GridLayout;
        }
        /**
         * A <code>FormElement</code> represents a row in a <code>FormContainer</code>.A
         * <code>FormElement</code> is a combination of one label and different controls associated to this
         * label.
         * @resource sap/ui/layout/form/FormElement.js
        */
        export class FormElement extends sap.ui.core.Element {


          /**
           * Constructor for a new sap.ui.layout.form.FormElement.Accepts an object literal
           * <code>mSettings</code> that defines initialproperty values, aggregated and associated objects as
           * well as event handlers.See {@link sap.ui.base.ManagedObject#constructor} for a general description
           * of the syntax of the settings object.
           * @param sId Id for the new control, generated automatically if no id is given
           * @param mSettings initial settings for the new control
          */
          constructor(sId: string, mSettings?: any);



          /**
           * Adds some field to the aggregation <code>fields</code>.
           * @param oField the field to add; if empty, nothing is inserted
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          addField(oField: sap.ui.core.Control): sap.ui.layout.form.FormElement;

          /**
           * Destroys all the fields in the aggregation <code>fields</code>.
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          destroyFields(): sap.ui.layout.form.FormElement;

          /**
           * Destroys the label in the aggregation <code>label</code>.
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          destroyLabel(): sap.ui.layout.form.FormElement;


          /**
           * Gets content of aggregation <code>fields</code>.Formular controls that belong together to be
           * displayed in one row of a <code>Form</code>.<b>Note:</b> Do not put any layout controls in here.
           * This could destroy the visual layout,keyboard support and screen-reader support.
          */
          getFields(): sap.ui.core.Control[];

          /**
           * Gets content of aggregation <code>label</code>.Label of the fields. Can either be a
           * <code>Label</code> object, or a string.If a <code>Label</code> object is used, the properties of the
           * <code>Label</code> can be set.If no assignment between <code>Label</code> and the fields is set, it
           * will be done automatically by the<code>FormElement</code>. In this case the <code>Label</code> is
           * assigned to the fields of the <code>FormElement</code>.
          */
          getLabel(): any | string;

          /**
           * Returns the <code>Label</code> of the <code>FormElement</code>, even if the <code>Label</code> is
           * assigned as string.The <code>FormLayout</code> needs the information of the label to render the
           * <code>Form</code>.
           * @returns <code>Label</code> control used to render the label
          */
          getLabelControl(): any;

          /**
           * Returns a metadata object for class sap.ui.layout.form.FormElement.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Gets current value of property <code>visible</code>.If set to <code>false</code>, the
           * <code>FormElement</code> is not rendered.Default value is <code>true</code>.
           * @returns Value of property <code>visible</code>
          */
          getVisible(): boolean;

          /**
           * Checks for the provided <code>sap.ui.core.Control</code> in the aggregation <code>fields</code>.and
           * returns its index if found or -1 otherwise.
           * @param oField The field whose index is looked for
           * @returns The index of the provided control in the aggregation if found, or -1 otherwise
          */
          indexOfField(oField: sap.ui.core.Control): number;

          /**
           * Inserts a field into the aggregation <code>fields</code>.
           * @param oField the field to insert; if empty, nothing is inserted
           * @param iIndex the <code>0</code>-based index the field should be inserted at; for             a
           * negative value of <code>iIndex</code>, the field is inserted at position 0; for a value            
           * greater than the current size of the aggregation, the field is inserted at             the last
           * position
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          insertField(oField: sap.ui.core.Control, iIndex: number): sap.ui.layout.form.FormElement;

          /**
           * Removes all the controls from the aggregation <code>fields</code>.Additionally, it unregisters them
           * from the hosting UIArea.
           * @returns An array of the removed elements (might be empty)
          */
          removeAllFields(): sap.ui.core.Control[];

          /**
           * Removes a field from the aggregation <code>fields</code>.
           * @param vField The field to remove or its index or id
           * @returns The removed field or <code>null</code>
          */
          removeField(vField: number | string | sap.ui.core.Control): sap.ui.core.Control;

          /**
           * Sets the aggregated <code>label</code>.
           * @param vLabel The label to set
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setLabel(vLabel: any | string): sap.ui.layout.form.FormElement;

          /**
           * Sets a new value for property <code>visible</code>.If set to <code>false</code>, the
           * <code>FormElement</code> is not rendered.When called with a value of <code>null</code> or
           * <code>undefined</code>, the default value of the property will be restored.Default value is
           * <code>true</code>.
           * @param bVisible New value for property <code>visible</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setVisible(bVisible: boolean): sap.ui.layout.form.FormElement;
        }
        /**
         * A <code>FormContainer</code> represents a group inside a <code>Form</code>. It consists of
         * <code>FormElements</code>.The rendering of the <code>FormContainer</code> is done by the
         * <code>FormLayout</code> assigned to the <code>Form</code>.
         * @resource sap/ui/layout/form/FormContainer.js
        */
        export class FormContainer extends sap.ui.core.Element {


          /**
           * Constructor for a new sap.ui.layout.form.FormContainer.Accepts an object literal
           * <code>mSettings</code> that defines initialproperty values, aggregated and associated objects as
           * well as event handlers.See {@link sap.ui.base.ManagedObject#constructor} for a general description
           * of the syntax of the settings object.
           * @param sId Id for the new control, generated automatically if no id is given
           * @param mSettings initial settings for the new control
          */
          constructor(sId: string, mSettings?: any);



          /**
           * Adds some ariaLabelledBy into the association <code>ariaLabelledBy</code>.
           * @since 1.36.0
           * @param vAriaLabelledBy the ariaLabelledBy to add; if empty, nothing is inserted
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          addAriaLabelledBy(vAriaLabelledBy: any | sap.ui.core.Control): sap.ui.layout.form.FormContainer;

          /**
           * Adds some formElement to the aggregation <code>formElements</code>.
           * @param oFormElement the formElement to add; if empty, nothing is inserted
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          addFormElement(oFormElement: sap.ui.layout.form.FormElement): sap.ui.layout.form.FormContainer;

          /**
           * Destroys all the formElements in the aggregation <code>formElements</code>.
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          destroyFormElements(): sap.ui.layout.form.FormContainer;

          /**
           * Destroys the title in the aggregation <code>title</code>.
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          destroyTitle(): sap.ui.layout.form.FormContainer;

          /**
           * Destroys the toolbar in the aggregation <code>toolbar</code>.
           * @since 1.36.0
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          destroyToolbar(): sap.ui.layout.form.FormContainer;


          /**
           * Returns array of IDs of the elements which are the current targets of the association
           * <code>ariaLabelledBy</code>.
           * @since 1.36.0
          */
          getAriaLabelledBy(): any[];

          /**
           * Gets current value of property <code>expandable</code>.Defines if the <code>FormContainer</code> is
           * expandable.<b>Note:</b> The expander icon will only be shown if a <code>title</code> is set for the
           * <code>FormContainer</code>.Default value is <code>false</code>.
           * @returns Value of property <code>expandable</code>
          */
          getExpandable(): boolean;

          /**
           * Gets current value of property <code>expanded</code>.Container is expanded.<b>Note:</b> This
           * property only works if <code>expandable</code> is set to <code>true</code>.Default value is
           * <code>true</code>.
           * @returns Value of property <code>expanded</code>
          */
          getExpanded(): boolean;

          /**
           * Gets content of aggregation <code>formElements</code>.The <code>FormElements</code> contain the
           * content (labels and fields) of the <code>FormContainers</code>.
          */
          getFormElements(): sap.ui.layout.form.FormElement[];

          /**
           * Returns a metadata object for class sap.ui.layout.form.FormContainer.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Gets content of aggregation <code>title</code>.Title of the <code>FormContainer</code>. Can either
           * be a <code>Title</code> object, or a string.If a <code>Title</code> object is used, the style of the
           * title can be set.<b>Note:</b> If a <code>Toolbar</code> is used, the <code>Title</code> is ignored.
          */
          getTitle(): sap.ui.core.Title | string;

          /**
           * Gets content of aggregation <code>toolbar</code>.Toolbar of the
           * <code>FormContainer</code>.<b>Note:</b> If a <code>Toolbar</code> is used, the <code>Title</code> is
           * ignored.If a title is needed inside the <code>Toolbar</code> it must be added at content to the
           * <code>Toolbar</code>.In this case add the <code>Title</code> to the <code>ariaLabelledBy</code>
           * association.
           * @since 1.36.0
          */
          getToolbar(): sap.ui.core.Toolbar;

          /**
           * Gets current value of property <code>visible</code>.If set to <code>false</code>, the
           * <code>FormContainer</code> is not rendered.Default value is <code>true</code>.
           * @returns Value of property <code>visible</code>
          */
          getVisible(): boolean;

          /**
           * Checks for the provided <code>sap.ui.layout.form.FormElement</code> in the aggregation
           * <code>formElements</code>.and returns its index if found or -1 otherwise.
           * @param oFormElement The formElement whose index is looked for
           * @returns The index of the provided control in the aggregation if found, or -1 otherwise
          */
          indexOfFormElement(oFormElement: sap.ui.layout.form.FormElement): number;

          /**
           * Inserts a formElement into the aggregation <code>formElements</code>.
           * @param oFormElement the formElement to insert; if empty, nothing is inserted
           * @param iIndex the <code>0</code>-based index the formElement should be inserted at; for            
           * a negative value of <code>iIndex</code>, the formElement is inserted at position 0; for a value     
           *        greater than the current size of the aggregation, the formElement is inserted at            
           * the last position
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          insertFormElement(oFormElement: sap.ui.layout.form.FormElement, iIndex: number): sap.ui.layout.form.FormContainer;

          /**
           * Removes all the controls in the association named <code>ariaLabelledBy</code>.
           * @since 1.36.0
           * @returns An array of the removed elements (might be empty)
          */
          removeAllAriaLabelledBy(): any[];

          /**
           * Removes all the controls from the aggregation <code>formElements</code>.Additionally, it unregisters
           * them from the hosting UIArea.
           * @returns An array of the removed elements (might be empty)
          */
          removeAllFormElements(): sap.ui.layout.form.FormElement[];

          /**
           * Removes an ariaLabelledBy from the association named <code>ariaLabelledBy</code>.
           * @since 1.36.0
           * @param vAriaLabelledBy The ariaLabelledBy to be removed or its index or ID
           * @returns The removed ariaLabelledBy or <code>null</code>
          */
          removeAriaLabelledBy(vAriaLabelledBy: number | any | sap.ui.core.Control): any;

          /**
           * Removes a formElement from the aggregation <code>formElements</code>.
           * @param vFormElement The formElement to remove or its index or id
           * @returns The removed formElement or <code>null</code>
          */
          removeFormElement(vFormElement: number | string | sap.ui.layout.form.FormElement): sap.ui.layout.form.FormElement;

          /**
           * Sets a new value for property <code>expandable</code>.Defines if the <code>FormContainer</code> is
           * expandable.<b>Note:</b> The expander icon will only be shown if a <code>title</code> is set for the
           * <code>FormContainer</code>.When called with a value of <code>null</code> or <code>undefined</code>,
           * the default value of the property will be restored.Default value is <code>false</code>.
           * @param bExpandable New value for property <code>expandable</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setExpandable(bExpandable: boolean): sap.ui.layout.form.FormContainer;

          /**
           * Sets a new value for property <code>expanded</code>.Container is expanded.<b>Note:</b> This property
           * only works if <code>expandable</code> is set to <code>true</code>.When called with a value of
           * <code>null</code> or <code>undefined</code>, the default value of the property will be
           * restored.Default value is <code>true</code>.
           * @param bExpanded New value for property <code>expanded</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setExpanded(bExpanded: boolean): sap.ui.layout.form.FormContainer;

          /**
           * Sets the aggregated <code>title</code>.
           * @param vTitle The title to set
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setTitle(vTitle: sap.ui.core.Title | string): sap.ui.layout.form.FormContainer;

          /**
           * Sets the aggregated <code>toolbar</code>.
           * @since 1.36.0
           * @param oToolbar The toolbar to set
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setToolbar(oToolbar: sap.ui.core.Toolbar): sap.ui.layout.form.FormContainer;

          /**
           * Sets a new value for property <code>visible</code>.If set to <code>false</code>, the
           * <code>FormContainer</code> is not rendered.When called with a value of <code>null</code> or
           * <code>undefined</code>, the default value of the property will be restored.Default value is
           * <code>true</code>.
           * @param bVisible New value for property <code>visible</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setVisible(bVisible: boolean): sap.ui.layout.form.FormContainer;
        }
        /**
         * The <code>GridLayout</code>-specific layout data for <code>FormElement</code> fields.
         * @resource sap/ui/layout/form/GridElementData.js
        */
        export class GridElementData extends sap.ui.core.LayoutData {


          /**
           * Constructor for a new sap.ui.layout.form.GridElementData.Accepts an object literal
           * <code>mSettings</code> that defines initialproperty values, aggregated and associated objects as
           * well as event handlers.See {@link sap.ui.base.ManagedObject#constructor} for a general description
           * of the syntax of the settings object.
           * @param sId Id for the new control, generated automatically if no id is given
           * @param mSettings initial settings for the new control
          */
          constructor(sId: string, mSettings?: any);




          /**
           * Gets current value of property <code>hCells</code>.Number of cells in horizontal direction.If set to
           * "auto" the size is determined by the number of fields and the available cells. For labels the auto
           * size is 3 cells.If set to "full" only one field is allowed within the <code>FormElement</code>. It
           * gets the full width of the row and the label is displayed above. <b>Note:</b> For labels full size
           * has no effect.Default value is <code>auto</code>.
           * @returns Value of property <code>hCells</code>
          */
          getHCells(): any;

          /**
           * Returns a metadata object for class sap.ui.layout.form.GridElementData.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Gets current value of property <code>vCells</code>.Number of cells in vertical
           * direction.<b>Note:</b> This property has no effect for labels.Default value is <code>1</code>.
           * @returns Value of property <code>vCells</code>
          */
          getVCells(): number;

          /**
           * Sets a new value for property <code>hCells</code>.Number of cells in horizontal direction.If set to
           * "auto" the size is determined by the number of fields and the available cells. For labels the auto
           * size is 3 cells.If set to "full" only one field is allowed within the <code>FormElement</code>. It
           * gets the full width of the row and the label is displayed above. <b>Note:</b> For labels full size
           * has no effect.When called with a value of <code>null</code> or <code>undefined</code>, the default
           * value of the property will be restored.Default value is <code>auto</code>.
           * @param sHCells New value for property <code>hCells</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setHCells(sHCells: any): sap.ui.layout.form.GridElementData;

          /**
           * Sets a new value for property <code>vCells</code>.Number of cells in vertical direction.<b>Note:</b>
           * This property has no effect for labels.When called with a value of <code>null</code> or
           * <code>undefined</code>, the default value of the property will be restored.Default value is
           * <code>1</code>.
           * @param iVCells New value for property <code>vCells</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setVCells(iVCells: number): sap.ui.layout.form.GridElementData;
        }
        /**
         * Renders a <code>Form</code> with a responsive layout. Internally the
         * <code>ResponsiveFlowLayout</code> is used.The responsiveness of this layout tries to best use the
         * available space. This means that the order of the <code>FormContainers</code>, labels and fields
         * depends on the available space.On the <code>FormContainers</code>, <code>FormElements</code>, labels
         * and content fields, <code>ResponsiveFlowLayoutData</code> can be used to change the default
         * rendering.We suggest using the <code>ResponsiveGridLayout</code> instead of this layout because this
         * is easier to consume and brings more stable responsive output.<b>Note:</b> If
         * <code>ResponsiveFlowLayoutData</code> are used this may result in a much more complex layout than
         * the default one. This means that in some cases, the calculation for the other content may not bring
         * the expected result.In such cases, <code>ResponsiveFlowLayoutData</code> should be used for all
         * content controls to disable the default behavior.This control cannot be used stand alone, it only
         * renders a <code>Form</code>, so it must be assigned to a <code>Form</code>.
         * @resource sap/ui/layout/form/ResponsiveLayout.js
        */
        export class ResponsiveLayout extends sap.ui.layout.form.FormLayout {


          /**
           * Constructor for a new sap.ui.layout.form.ResponsiveLayout.
           * @param sId Id for the new control, generated automatically if no id is given
           * @param mSettings initial settings for the new control
          */
          constructor(sId: string, mSettings?: any);




          /**
           * Returns a metadata object for class sap.ui.layout.form.ResponsiveLayout.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;
        }
        /**
         * <code>GridLayout</code>-specific properties for <code>FormContainers</code>.
         * @resource sap/ui/layout/form/GridContainerData.js
        */
        export class GridContainerData extends sap.ui.core.LayoutData {


          /**
           * Constructor for a new sap.ui.layout.form.GridContainerData.Accepts an object literal
           * <code>mSettings</code> that defines initialproperty values, aggregated and associated objects as
           * well as event handlers.See {@link sap.ui.base.ManagedObject#constructor} for a general description
           * of the syntax of the settings object.
           * @param sId Id for the new control, generated automatically if no id is given
           * @param mSettings initial settings for the new control
          */
          constructor(sId: string, mSettings?: any);




          /**
           * Gets current value of property <code>halfGrid</code>.If set, the container takes half the width of
           * the <code>Form</code> (8 cells), if not it takes the full width (16 cells).If the
           * <code>GridLayout</code> is set to <code>singleColumn</code>, the full width of the grid is only 8
           * cells. So containers are rendered only once per row.Default value is <code>false</code>.
           * @returns Value of property <code>halfGrid</code>
          */
          getHalfGrid(): boolean;

          /**
           * Returns a metadata object for class sap.ui.layout.form.GridContainerData.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Sets a new value for property <code>halfGrid</code>.If set, the container takes half the width of
           * the <code>Form</code> (8 cells), if not it takes the full width (16 cells).If the
           * <code>GridLayout</code> is set to <code>singleColumn</code>, the full width of the grid is only 8
           * cells. So containers are rendered only once per row.When called with a value of <code>null</code> or
           * <code>undefined</code>, the default value of the property will be restored.Default value is
           * <code>false</code>.
           * @param bHalfGrid New value for property <code>halfGrid</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setHalfGrid(bHalfGrid: boolean): sap.ui.layout.form.GridContainerData;
        }
        /**
         * Renders a <code>Form</code> using a responsive grid. Internally the <code>Grid</code> control is
         * used for rendering.Using this layout, the <code>Form</code> is rendered in a responsive
         * way.Depending on the available space, the <code>FormContainers</code> are rendered in one or
         * different columns and the labels are rendered in the same row as the fields or above the fields.This
         * behavior can be influenced by the properties of this layout control.On the
         * <code>FormContainers</code>, labels and content fields, <code>GridData</code> can be used to change
         * the default rendering.<code>GridData</code> is not supported for
         * <code>FormElements</code>.<b>Note:</b> If <code>GridData</code> is used, this may result in a much
         * more complex layout than the default one.This means that in some cases, the calculation for the
         * other content may not bring the expected result.In such cases, <code>GridData</code> should be used
         * for all content controls to disable the default behavior.This control cannot be used standalone, it
         * only renders a <code>Form</code>, so it must be assigned to a <code>Form</code>.
         * @resource sap/ui/layout/form/ResponsiveGridLayout.js
        */
        export class ResponsiveGridLayout extends sap.ui.layout.form.FormLayout {


          /**
           * Constructor for a new <code>sap.ui.layout.form.ResponsiveGridLayout</code>.Accepts an object literal
           * <code>mSettings</code> that defines initialproperty values, aggregated and associated objects as
           * well as event handlers.See {@link sap.ui.base.ManagedObject#constructor} for a general description
           * of the syntax of the settings object.
           * @param sId ID for the new control, generated automatically if no ID is given
           * @param mSettings Initial settings for the new control
          */
          constructor(sId: string, mSettings?: any);




          /**
           * Gets current value of property <code>adjustLabelSpan</code>.If set, the usage of
           * <code>labelSpanL</code> and <code>labelSpanM</code> are dependent on the number of
           * <code>FormContainers</code> in one row.If only one <code>FormContainer</code> is displayed in one
           * row, <code>labelSpanM</code> is used to define the size of the label.This is the same for medium and
           * large <code>Forms</code>.This is done to align the labels on forms where full-size
           * <code>FormContainers</code> and multiple-column rows are used in the same <code>Form</code>(because
           * every <code>FormContainer</code> has its own grid inside).If not set, the usage of
           * <code>labelSpanL</code> and <code>labelSpanM</code> are dependent on the <code>Form</code> size.The
           * number of <code>FormContainers</code> doesn't matter in this case.Default value is
           * <code>true</code>.
           * @since 1.34.0
           * @returns Value of property <code>adjustLabelSpan</code>
          */
          getAdjustLabelSpan(): boolean;

          /**
           * Gets current value of property <code>breakpointL</code>.Breakpoint (in pixel) between Medium size
           * and Large size.Default value is <code>1024</code>.
           * @since 1.16.3
           * @returns Value of property <code>breakpointL</code>
          */
          getBreakpointL(): number;

          /**
           * Gets current value of property <code>breakpointM</code>.Breakpoint (in pixel) between Small size and
           * Medium size.Default value is <code>600</code>.
           * @since 1.16.3
           * @returns Value of property <code>breakpointM</code>
          */
          getBreakpointM(): number;

          /**
           * Gets current value of property <code>breakpointXL</code>.Breakpoint (in pixel) between large size
           * and extra large (XL) size.Default value is <code>1440</code>.
           * @since 1.34.0
           * @returns Value of property <code>breakpointXL</code>
          */
          getBreakpointXL(): number;

          /**
           * Gets current value of property <code>columnsL</code>.Number of columns for large size.The number of
           * columns for large size must not be smaller than the number of columns for medium size.Default value
           * is <code>2</code>.
           * @since 1.16.3
           * @returns Value of property <code>columnsL</code>
          */
          getColumnsL(): number;

          /**
           * Gets current value of property <code>columnsM</code>.Number of columns for medium size.Default value
           * is <code>1</code>.
           * @since 1.16.3
           * @returns Value of property <code>columnsM</code>
          */
          getColumnsM(): number;

          /**
           * Gets current value of property <code>columnsXL</code>.Number of columns for extra large size.The
           * number of columns for extra large size must not be smaller than the number of columns for large
           * size.<b>Note:</b> If the default value -1 is not overwritten with the meaningful one then the
           * <code>columnsL</code> value is used (from the backward compatibility reasons).Default value is
           * <code>-1</code>.
           * @since 1.34.0
           * @returns Value of property <code>columnsXL</code>
          */
          getColumnsXL(): number;

          /**
           * Gets current value of property <code>emptySpanL</code>.Number of grid cells that are empty at the
           * end of each line on large size.Default value is <code>0</code>.
           * @since 1.16.3
           * @returns Value of property <code>emptySpanL</code>
          */
          getEmptySpanL(): number;

          /**
           * Gets current value of property <code>emptySpanM</code>.Number of grid cells that are empty at the
           * end of each line on medium size.Default value is <code>0</code>.
           * @since 1.16.3
           * @returns Value of property <code>emptySpanM</code>
          */
          getEmptySpanM(): number;

          /**
           * Gets current value of property <code>emptySpanS</code>.Number of grid cells that are empty at the
           * end of each line on small size.Default value is <code>0</code>.
           * @since 1.16.3
           * @returns Value of property <code>emptySpanS</code>
          */
          getEmptySpanS(): number;

          /**
           * Gets current value of property <code>emptySpanXL</code>.Number of grid cells that are empty at the
           * end of each line on extra large size.<b>Note:</b> If the default value -1 is not overwritten with
           * the meaningful one then the <code>emptySpanL</code> value is used.Default value is <code>-1</code>.
           * @since 1.34.0
           * @returns Value of property <code>emptySpanXL</code>
          */
          getEmptySpanXL(): number;

          /**
           * Gets current value of property <code>labelSpanL</code>.Default span for labels in large
           * size.<b>Note:</b> If <code>adjustLabelSpanThis</code> is set, this property is only used if more
           * than 1 <code>FormContainer</code> is in one line. If only 1 <code>FormContainer</code> is in the
           * line, then the <code>labelSpanM</code> value is used.Default value is <code>4</code>.
           * @since 1.16.3
           * @returns Value of property <code>labelSpanL</code>
          */
          getLabelSpanL(): number;

          /**
           * Gets current value of property <code>labelSpanM</code>.Default span for labels in medium
           * size.<b>Note:</b> If <code>adjustLabelSpanThis</code> is set this property is used for full-size
           * <code>FormContainers</code>. If more than one <code>FormContainer</code> is in one line,
           * <code>labelSpanL</code> is used.Default value is <code>2</code>.
           * @since 1.16.3
           * @returns Value of property <code>labelSpanM</code>
          */
          getLabelSpanM(): number;

          /**
           * Gets current value of property <code>labelSpanS</code>.Default span for labels in small size.Default
           * value is <code>12</code>.
           * @since 1.16.3
           * @returns Value of property <code>labelSpanS</code>
          */
          getLabelSpanS(): number;

          /**
           * Gets current value of property <code>labelSpanXL</code>.Default span for labels in extra large
           * size.<b>Note:</b> If the default value -1 is not overwritten with the meaningful one then the
           * <code>labelSpanL</code> value is used.Default value is <code>-1</code>.
           * @since 1.34.0
           * @returns Value of property <code>labelSpanXL</code>
          */
          getLabelSpanXL(): number;

          /**
           * Returns a metadata object for class sap.ui.layout.form.ResponsiveGridLayout.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Gets current value of property <code>singleContainerFullSize</code>.If the <code>Form</code>
           * contains only one single <code>FormContainer</code> and this property is set,the
           * <code>FormContainer</code> is displayed using the full size of the <code>Form</code>.In this case
           * the properties <code>columnsXL</code>, <code>columnsL</code> and <code>columnsM</code> are
           * ignored.In all other cases the <code>FormContainer</code> is displayed in the size of one
           * column.Default value is <code>true</code>.
           * @since 1.34.0
           * @returns Value of property <code>singleContainerFullSize</code>
          */
          getSingleContainerFullSize(): boolean;

          /**
           * Sets a new value for property <code>adjustLabelSpan</code>.If set, the usage of
           * <code>labelSpanL</code> and <code>labelSpanM</code> are dependent on the number of
           * <code>FormContainers</code> in one row.If only one <code>FormContainer</code> is displayed in one
           * row, <code>labelSpanM</code> is used to define the size of the label.This is the same for medium and
           * large <code>Forms</code>.This is done to align the labels on forms where full-size
           * <code>FormContainers</code> and multiple-column rows are used in the same <code>Form</code>(because
           * every <code>FormContainer</code> has its own grid inside).If not set, the usage of
           * <code>labelSpanL</code> and <code>labelSpanM</code> are dependent on the <code>Form</code> size.The
           * number of <code>FormContainers</code> doesn't matter in this case.When called with a value of
           * <code>null</code> or <code>undefined</code>, the default value of the property will be
           * restored.Default value is <code>true</code>.
           * @since 1.34.0
           * @param bAdjustLabelSpan New value for property <code>adjustLabelSpan</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setAdjustLabelSpan(bAdjustLabelSpan: boolean): sap.ui.layout.form.ResponsiveGridLayout;

          /**
           * Sets a new value for property <code>breakpointL</code>.Breakpoint (in pixel) between Medium size and
           * Large size.When called with a value of <code>null</code> or <code>undefined</code>, the default
           * value of the property will be restored.Default value is <code>1024</code>.
           * @since 1.16.3
           * @param iBreakpointL New value for property <code>breakpointL</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setBreakpointL(iBreakpointL: number): sap.ui.layout.form.ResponsiveGridLayout;

          /**
           * Sets a new value for property <code>breakpointM</code>.Breakpoint (in pixel) between Small size and
           * Medium size.When called with a value of <code>null</code> or <code>undefined</code>, the default
           * value of the property will be restored.Default value is <code>600</code>.
           * @since 1.16.3
           * @param iBreakpointM New value for property <code>breakpointM</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setBreakpointM(iBreakpointM: number): sap.ui.layout.form.ResponsiveGridLayout;

          /**
           * Sets a new value for property <code>breakpointXL</code>.Breakpoint (in pixel) between large size and
           * extra large (XL) size.When called with a value of <code>null</code> or <code>undefined</code>, the
           * default value of the property will be restored.Default value is <code>1440</code>.
           * @since 1.34.0
           * @param iBreakpointXL New value for property <code>breakpointXL</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setBreakpointXL(iBreakpointXL: number): sap.ui.layout.form.ResponsiveGridLayout;

          /**
           * Sets a new value for property <code>columnsL</code>.Number of columns for large size.The number of
           * columns for large size must not be smaller than the number of columns for medium size.When called
           * with a value of <code>null</code> or <code>undefined</code>, the default value of the property will
           * be restored.Default value is <code>2</code>.
           * @since 1.16.3
           * @param iColumnsL New value for property <code>columnsL</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setColumnsL(iColumnsL: number): sap.ui.layout.form.ResponsiveGridLayout;

          /**
           * Sets a new value for property <code>columnsM</code>.Number of columns for medium size.When called
           * with a value of <code>null</code> or <code>undefined</code>, the default value of the property will
           * be restored.Default value is <code>1</code>.
           * @since 1.16.3
           * @param iColumnsM New value for property <code>columnsM</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setColumnsM(iColumnsM: number): sap.ui.layout.form.ResponsiveGridLayout;

          /**
           * Sets a new value for property <code>columnsXL</code>.Number of columns for extra large size.The
           * number of columns for extra large size must not be smaller than the number of columns for large
           * size.<b>Note:</b> If the default value -1 is not overwritten with the meaningful one then the
           * <code>columnsL</code> value is used (from the backward compatibility reasons).When called with a
           * value of <code>null</code> or <code>undefined</code>, the default value of the property will be
           * restored.Default value is <code>-1</code>.
           * @since 1.34.0
           * @param iColumnsXL New value for property <code>columnsXL</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setColumnsXL(iColumnsXL: number): sap.ui.layout.form.ResponsiveGridLayout;

          /**
           * Sets a new value for property <code>emptySpanL</code>.Number of grid cells that are empty at the end
           * of each line on large size.When called with a value of <code>null</code> or <code>undefined</code>,
           * the default value of the property will be restored.Default value is <code>0</code>.
           * @since 1.16.3
           * @param iEmptySpanL New value for property <code>emptySpanL</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setEmptySpanL(iEmptySpanL: number): sap.ui.layout.form.ResponsiveGridLayout;

          /**
           * Sets a new value for property <code>emptySpanM</code>.Number of grid cells that are empty at the end
           * of each line on medium size.When called with a value of <code>null</code> or <code>undefined</code>,
           * the default value of the property will be restored.Default value is <code>0</code>.
           * @since 1.16.3
           * @param iEmptySpanM New value for property <code>emptySpanM</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setEmptySpanM(iEmptySpanM: number): sap.ui.layout.form.ResponsiveGridLayout;

          /**
           * Sets a new value for property <code>emptySpanS</code>.Number of grid cells that are empty at the end
           * of each line on small size.When called with a value of <code>null</code> or <code>undefined</code>,
           * the default value of the property will be restored.Default value is <code>0</code>.
           * @since 1.16.3
           * @param iEmptySpanS New value for property <code>emptySpanS</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setEmptySpanS(iEmptySpanS: number): sap.ui.layout.form.ResponsiveGridLayout;

          /**
           * Sets a new value for property <code>emptySpanXL</code>.Number of grid cells that are empty at the
           * end of each line on extra large size.<b>Note:</b> If the default value -1 is not overwritten with
           * the meaningful one then the <code>emptySpanL</code> value is used.When called with a value of
           * <code>null</code> or <code>undefined</code>, the default value of the property will be
           * restored.Default value is <code>-1</code>.
           * @since 1.34.0
           * @param iEmptySpanXL New value for property <code>emptySpanXL</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setEmptySpanXL(iEmptySpanXL: number): sap.ui.layout.form.ResponsiveGridLayout;

          /**
           * Sets a new value for property <code>labelSpanL</code>.Default span for labels in large
           * size.<b>Note:</b> If <code>adjustLabelSpanThis</code> is set, this property is only used if more
           * than 1 <code>FormContainer</code> is in one line. If only 1 <code>FormContainer</code> is in the
           * line, then the <code>labelSpanM</code> value is used.When called with a value of <code>null</code>
           * or <code>undefined</code>, the default value of the property will be restored.Default value is
           * <code>4</code>.
           * @since 1.16.3
           * @param iLabelSpanL New value for property <code>labelSpanL</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setLabelSpanL(iLabelSpanL: number): sap.ui.layout.form.ResponsiveGridLayout;

          /**
           * Sets a new value for property <code>labelSpanM</code>.Default span for labels in medium
           * size.<b>Note:</b> If <code>adjustLabelSpanThis</code> is set this property is used for full-size
           * <code>FormContainers</code>. If more than one <code>FormContainer</code> is in one line,
           * <code>labelSpanL</code> is used.When called with a value of <code>null</code> or
           * <code>undefined</code>, the default value of the property will be restored.Default value is
           * <code>2</code>.
           * @since 1.16.3
           * @param iLabelSpanM New value for property <code>labelSpanM</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setLabelSpanM(iLabelSpanM: number): sap.ui.layout.form.ResponsiveGridLayout;

          /**
           * Sets a new value for property <code>labelSpanS</code>.Default span for labels in small size.When
           * called with a value of <code>null</code> or <code>undefined</code>, the default value of the
           * property will be restored.Default value is <code>12</code>.
           * @since 1.16.3
           * @param iLabelSpanS New value for property <code>labelSpanS</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setLabelSpanS(iLabelSpanS: number): sap.ui.layout.form.ResponsiveGridLayout;

          /**
           * Sets a new value for property <code>labelSpanXL</code>.Default span for labels in extra large
           * size.<b>Note:</b> If the default value -1 is not overwritten with the meaningful one then the
           * <code>labelSpanL</code> value is used.When called with a value of <code>null</code> or
           * <code>undefined</code>, the default value of the property will be restored.Default value is
           * <code>-1</code>.
           * @since 1.34.0
           * @param iLabelSpanXL New value for property <code>labelSpanXL</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setLabelSpanXL(iLabelSpanXL: number): sap.ui.layout.form.ResponsiveGridLayout;

          /**
           * Sets a new value for property <code>singleContainerFullSize</code>.If the <code>Form</code> contains
           * only one single <code>FormContainer</code> and this property is set,the <code>FormContainer</code>
           * is displayed using the full size of the <code>Form</code>.In this case the properties
           * <code>columnsXL</code>, <code>columnsL</code> and <code>columnsM</code> are ignored.In all other
           * cases the <code>FormContainer</code> is displayed in the size of one column.When called with a value
           * of <code>null</code> or <code>undefined</code>, the default value of the property will be
           * restored.Default value is <code>true</code>.
           * @since 1.34.0
           * @param bSingleContainerFullSize New value for property <code>singleContainerFullSize</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setSingleContainerFullSize(bSingleContainerFullSize: boolean): sap.ui.layout.form.ResponsiveGridLayout;
        }
        /**
         * Available <code>FormLayouts</code> used to render a <code>SimpleForm</code>.
        */
        enum SimpleFormLayout {
          "GridLayout",
          "ResponsiveGridLayout",
          "ResponsiveLayout"
        }
      }
      namespace GridSpan {
      }
      namespace GridIndent {
      }
      namespace BlockBackgroundType {

        /**
         * Background is transparent
        */
        var Default: any;

        /**
         * Background is with predefined light colors
        */
        var Light: any;
      }
      /**
       * The Grid control is a layout which positions its child controls in a 12 column flow layout. Its
       * children can be specified to take on a variable amount of columns depending on available screen
       * size. With this control it is possible to achieve flexible layouts and line-breaks for extra large-,
       * large-, medium- and small-sized screens, such as large desktop, desktop, tablet, and mobile. The
       * Grid control's width can be percentage- or pixel-based and the spacing between its columns can be
       * set to various pre-defined values.
       * @resource sap/ui/layout/Grid.js
      */
      export class Grid extends sap.ui.core.Control {


        /**
         * Constructor for a new Grid.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Adds some content to the aggregation <code>content</code>.
         * @param oContent the content to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addContent(oContent: sap.ui.core.Control): sap.ui.layout.Grid;

        /**
         * Destroys all the content in the aggregation <code>content</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyContent(): sap.ui.layout.Grid;


        /**
        */
        getAccessibilityInfo(): void;

        /**
         * Gets current value of property <code>containerQuery</code>.If true then not the media Query ( device
         * screen size), but the size of the container surrounding the grid defines the current range (large,
         * medium or small).Default value is <code>false</code>.
         * @returns Value of property <code>containerQuery</code>
        */
        getContainerQuery(): boolean;

        /**
         * Gets content of aggregation <code>content</code>.Controls that are placed into Grid layout.
        */
        getContent(): sap.ui.core.Control[];

        /**
         * Gets current value of property <code>defaultIndent</code>.Optional. Defines default for the whole
         * Grid numbers of empty columns before the current span begins. It can be defined for large, medium
         * and small screens. Allowed values are separated by space Letters L, M or S followed by number of
         * columns from 0 to 11 that the container has to take, for example: "L2 M4 S6", "M11", "s10" or "l4
         * m4". Note that the parameters has to be provided in the order large medium small.Default value is
         * <code>XL0 L0 M0 S0</code>.
         * @returns Value of property <code>defaultIndent</code>
        */
        getDefaultIndent(): any;

        /**
         * Gets current value of property <code>defaultSpan</code>.Optional. A string type that represents
         * Grid's default span values for large, medium and small screens for the whole Grid. Allowed values
         * are separated by space Letters L, M or S followed by number of columns from 1 to 12 that the
         * container has to take, for example: "L2 M4 S6", "M12", "s10" or "l4 m4". Note that the parameters
         * has to be provided in the order large medium small.Default value is <code>XL3 L3 M6 S12</code>.
         * @returns Value of property <code>defaultSpan</code>
        */
        getDefaultSpan(): any;

        /**
         * Gets current value of property <code>hSpacing</code>.Optional. Horizontal spacing between the
         * content in the Grid. In rem, allowed values are 0, 0.5 , 1 or 2.Default value is <code>1</code>.
         * @returns Value of property <code>hSpacing</code>
        */
        getHSpacing(): number;

        /**
         * Returns a metadata object for class sap.ui.layout.Grid.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>position</code>.Optional. Position of the Grid in the window or
         * surrounding container. Possible values are "Center", "Left" and "Right".Default value is
         * <code>Left</code>.
         * @returns Value of property <code>position</code>
        */
        getPosition(): sap.ui.layout.GridPosition;

        /**
         * Gets current value of property <code>vSpacing</code>.Optional. Vertical spacing between the rows in
         * the Grid. In rem, allowed values are 0, 0.5, 1 and 2.Default value is <code>1</code>.
         * @returns Value of property <code>vSpacing</code>
        */
        getVSpacing(): number;

        /**
         * Gets current value of property <code>width</code>.Optional. Width of the Grid. If not specified,
         * then 100%.Default value is <code>100%</code>.
         * @returns Value of property <code>width</code>
        */
        getWidth(): any;

        /**
         * Checks for the provided <code>sap.ui.core.Control</code> in the aggregation <code>content</code>.and
         * returns its index if found or -1 otherwise.
         * @param oContent The content whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfContent(oContent: sap.ui.core.Control): number;

        /**
         * Inserts a content into the aggregation <code>content</code>.
         * @param oContent the content to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the content should be inserted at; for             a
         * negative value of <code>iIndex</code>, the content is inserted at position 0; for a value           
         *  greater than the current size of the aggregation, the content is inserted at             the last
         * position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertContent(oContent: sap.ui.core.Control, iIndex: number): sap.ui.layout.Grid;

        /**
         * Removes all the controls from the aggregation <code>content</code>.Additionally, it unregisters them
         * from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllContent(): sap.ui.core.Control[];

        /**
         * Removes a content from the aggregation <code>content</code>.
         * @param vContent The content to remove or its index or id
         * @returns The removed content or <code>null</code>
        */
        removeContent(vContent: number | string | sap.ui.core.Control): sap.ui.core.Control;

        /**
         * Sets a new value for property <code>containerQuery</code>.If true then not the media Query ( device
         * screen size), but the size of the container surrounding the grid defines the current range (large,
         * medium or small).When called with a value of <code>null</code> or <code>undefined</code>, the
         * default value of the property will be restored.Default value is <code>false</code>.
         * @param bContainerQuery New value for property <code>containerQuery</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setContainerQuery(bContainerQuery: boolean): sap.ui.layout.Grid;

        /**
         * Sets a new value for property <code>defaultIndent</code>.Optional. Defines default for the whole
         * Grid numbers of empty columns before the current span begins. It can be defined for large, medium
         * and small screens. Allowed values are separated by space Letters L, M or S followed by number of
         * columns from 0 to 11 that the container has to take, for example: "L2 M4 S6", "M11", "s10" or "l4
         * m4". Note that the parameters has to be provided in the order large medium small.When called with a
         * value of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>XL0 L0 M0 S0</code>.
         * @param sDefaultIndent New value for property <code>defaultIndent</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setDefaultIndent(sDefaultIndent: any): sap.ui.layout.Grid;

        /**
         * Sets a new value for property <code>defaultSpan</code>.Optional. A string type that represents
         * Grid's default span values for large, medium and small screens for the whole Grid. Allowed values
         * are separated by space Letters L, M or S followed by number of columns from 1 to 12 that the
         * container has to take, for example: "L2 M4 S6", "M12", "s10" or "l4 m4". Note that the parameters
         * has to be provided in the order large medium small.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.Default value is
         * <code>XL3 L3 M6 S12</code>.
         * @param sDefaultSpan New value for property <code>defaultSpan</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setDefaultSpan(sDefaultSpan: any): sap.ui.layout.Grid;

        /**
         * Sets a new value for property <code>hSpacing</code>.Optional. Horizontal spacing between the content
         * in the Grid. In rem, allowed values are 0, 0.5 , 1 or 2.When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>1</code>.
         * @param fHSpacing New value for property <code>hSpacing</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setHSpacing(fHSpacing: number): sap.ui.layout.Grid;

        /**
         * Sets a new value for property <code>position</code>.Optional. Position of the Grid in the window or
         * surrounding container. Possible values are "Center", "Left" and "Right".When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>Left</code>.
         * @param sPosition New value for property <code>position</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setPosition(sPosition: sap.ui.layout.GridPosition): sap.ui.layout.Grid;

        /**
         * Sets a new value for property <code>vSpacing</code>.Optional. Vertical spacing between the rows in
         * the Grid. In rem, allowed values are 0, 0.5, 1 and 2.When called with a value of <code>null</code>
         * or <code>undefined</code>, the default value of the property will be restored.Default value is
         * <code>1</code>.
         * @param fVSpacing New value for property <code>vSpacing</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setVSpacing(fVSpacing: number): sap.ui.layout.Grid;

        /**
         * Sets a new value for property <code>width</code>.Optional. Width of the Grid. If not specified, then
         * 100%.When called with a value of <code>null</code> or <code>undefined</code>, the default value of
         * the property will be restored.Default value is <code>100%</code>.
         * @param sWidth New value for property <code>width</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setWidth(sWidth: any): sap.ui.layout.Grid;
      }
      /**
       * The FixFlex control builds the container for a layout with a fixed and a flexible part. The flexible
       * container adapts its size to the fix container. The fix container can hold any number of controls,
       * while the flexible container can hold only one.In order for the FixFlex to stretch properly, the
       * parent element, in which the control is placed, needs to have a specified height or needs to have an
       * absolute position.Warning: Avoid nesting FixFlex in other flexbox based layout controls (FixFlex,
       * FlexBox, Hbox, Vbox). Otherwise contents may be not accessible or multiple scrollbars can
       * appear.Note: If the child control of the flex or the fix container has width/height bigger than the
       * container itself, the child control will be cropped in the view. If minFlexSize is set, then a
       * scrollbar is shown in the flexible part, depending on the vertical property.
       * @resource sap/ui/layout/FixFlex.js
      */
      export class FixFlex extends sap.ui.core.Control {


        /**
         * Constructor for a new FixFlex.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Adds some fixContent to the aggregation <code>fixContent</code>.
         * @param oFixContent the fixContent to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addFixContent(oFixContent: sap.ui.core.Control): sap.ui.layout.FixFlex;

        /**
         * Destroys all the fixContent in the aggregation <code>fixContent</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyFixContent(): sap.ui.layout.FixFlex;

        /**
         * Destroys the flexContent in the aggregation <code>flexContent</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyFlexContent(): sap.ui.layout.FixFlex;


        /**
         * Gets content of aggregation <code>fixContent</code>.Controls in the fixed part of the layout.
        */
        getFixContent(): sap.ui.core.Control[];

        /**
         * Gets current value of property <code>fixContentSize</code>.Determines the height (if the vertical
         * property is "true") or the width (if the vertical property is "false") of the fixed area. If left at
         * the default value "auto", the fixed-size area will be as large as its content. In this case the
         * content cannot use percentage sizes.Default value is <code>auto</code>.
         * @returns Value of property <code>fixContentSize</code>
        */
        getFixContentSize(): any;

        /**
         * Gets current value of property <code>fixFirst</code>.Determines whether the fixed-size area should
         * be on the beginning/top ( if the value is "true") or beginning/bottom ( if the value is
         * "false").Default value is <code>true</code>.
         * @returns Value of property <code>fixFirst</code>
        */
        getFixFirst(): boolean;

        /**
         * Gets content of aggregation <code>flexContent</code>.Control in the stretching part of the layout.
        */
        getFlexContent(): sap.ui.core.Control;

        /**
         * Returns a metadata object for class sap.ui.layout.FixFlex.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>minFlexSize</code>.Enables scrolling inside the flexible part.
         * The given size is calculated in "px". If the child control in the flexible part is larger then the
         * available flexible size on the screen and if the available size for the flexible part is smaller or
         * equal to the minFlexSize value, the scroll will be for the entire FixFlex control.Default value is
         * <code>0</code>.
         * @since 1.29
         * @returns Value of property <code>minFlexSize</code>
        */
        getMinFlexSize(): number;

        /**
         * Gets current value of property <code>vertical</code>.Determines the direction of the layout of child
         * elements. True for vertical and false for horizontal layout.Default value is <code>true</code>.
         * @returns Value of property <code>vertical</code>
        */
        getVertical(): boolean;

        /**
         * Checks for the provided <code>sap.ui.core.Control</code> in the aggregation
         * <code>fixContent</code>.and returns its index if found or -1 otherwise.
         * @param oFixContent The fixContent whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfFixContent(oFixContent: sap.ui.core.Control): number;

        /**
         * Inserts a fixContent into the aggregation <code>fixContent</code>.
         * @param oFixContent the fixContent to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the fixContent should be inserted at; for             a
         * negative value of <code>iIndex</code>, the fixContent is inserted at position 0; for a value        
         *     greater than the current size of the aggregation, the fixContent is inserted at             the
         * last position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertFixContent(oFixContent: sap.ui.core.Control, iIndex: number): sap.ui.layout.FixFlex;

        /**
         * Removes all the controls from the aggregation <code>fixContent</code>.Additionally, it unregisters
         * them from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllFixContent(): sap.ui.core.Control[];

        /**
         * Removes a fixContent from the aggregation <code>fixContent</code>.
         * @param vFixContent The fixContent to remove or its index or id
         * @returns The removed fixContent or <code>null</code>
        */
        removeFixContent(vFixContent: number | string | sap.ui.core.Control): sap.ui.core.Control;

        /**
         * Sets a new value for property <code>fixContentSize</code>.Determines the height (if the vertical
         * property is "true") or the width (if the vertical property is "false") of the fixed area. If left at
         * the default value "auto", the fixed-size area will be as large as its content. In this case the
         * content cannot use percentage sizes.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.Default value is
         * <code>auto</code>.
         * @param sFixContentSize New value for property <code>fixContentSize</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setFixContentSize(sFixContentSize: any): sap.ui.layout.FixFlex;

        /**
         * Sets a new value for property <code>fixFirst</code>.Determines whether the fixed-size area should be
         * on the beginning/top ( if the value is "true") or beginning/bottom ( if the value is "false").When
         * called with a value of <code>null</code> or <code>undefined</code>, the default value of the
         * property will be restored.Default value is <code>true</code>.
         * @param bFixFirst New value for property <code>fixFirst</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setFixFirst(bFixFirst: boolean): sap.ui.layout.FixFlex;

        /**
         * Sets the aggregated <code>flexContent</code>.
         * @param oFlexContent The flexContent to set
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setFlexContent(oFlexContent: sap.ui.core.Control): sap.ui.layout.FixFlex;

        /**
         * Sets a new value for property <code>minFlexSize</code>.Enables scrolling inside the flexible part.
         * The given size is calculated in "px". If the child control in the flexible part is larger then the
         * available flexible size on the screen and if the available size for the flexible part is smaller or
         * equal to the minFlexSize value, the scroll will be for the entire FixFlex control.When called with a
         * value of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>0</code>.
         * @since 1.29
         * @param iMinFlexSize New value for property <code>minFlexSize</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setMinFlexSize(iMinFlexSize: number): sap.ui.layout.FixFlex;

        /**
         * Sets a new value for property <code>vertical</code>.Determines the direction of the layout of child
         * elements. True for vertical and false for horizontal layout.When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>true</code>.
         * @param bVertical New value for property <code>vertical</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setVertical(bVertical: boolean): sap.ui.layout.FixFlex;
      }
      /**
       * Grid layout data
       * @resource sap/ui/layout/GridData.js
      */
      export class GridData extends sap.ui.core.LayoutData {


        /**
         * Constructor for a new GridData.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);




        /**
         * Gets current value of property <code>indent</code>.A string type that represents Grid's span values
         * for large, medium and small screens. Allowed values are separated by space Letters L, M or S
         * followed by number of columns from 1 to 12 that the container has to take, for example: "L2 M4 S6",
         * "M12", "s10" or "l4 m4". Note that the parameters has to be provided in the order large medium
         * small.
         * @returns Value of property <code>indent</code>
        */
        getIndent(): any;

        /**
         * Gets current value of property <code>indentL</code>.Optional. Defines a span value for large
         * screens. This value overwrites the value for large screens defined in the parameter "indent".
         * @returns Value of property <code>indentL</code>
        */
        getIndentL(): number;

        /**
         * Gets current value of property <code>indentLarge</code>.Deprecated. Defines a span value for large
         * screens. This value overwrites the value for large screens defined in the parameter "indent".
         * @returns Value of property <code>indentLarge</code>
        */
        getIndentLarge(): number;

        /**
         * Gets current value of property <code>indentM</code>.Optional. Defines a span value for medium size
         * screens. This value overwrites the value for medium screens defined in the parameter "indent".
         * @returns Value of property <code>indentM</code>
        */
        getIndentM(): number;

        /**
         * Gets current value of property <code>indentMedium</code>.Deprecated. Defines a span value for medium
         * size screens. This value overwrites the value for medium screens defined in the parameter "indent".
         * @returns Value of property <code>indentMedium</code>
        */
        getIndentMedium(): number;

        /**
         * Gets current value of property <code>indentS</code>.Optional. Defines a span value for small
         * screens. This value overwrites the value for small screens defined in the parameter "indent".
         * @returns Value of property <code>indentS</code>
        */
        getIndentS(): number;

        /**
         * Gets current value of property <code>indentSmall</code>.Deprecated. Defines a span value for small
         * screens. This value overwrites the value for small screens defined in the parameter "indent".
         * @returns Value of property <code>indentSmall</code>
        */
        getIndentSmall(): number;

        /**
         * Gets current value of property <code>indentXL</code>.Optional. Defines a span value for extra large
         * screens. This value overwrites the value for extra large screens defined in the parameter "indent".
         * @returns Value of property <code>indentXL</code>
        */
        getIndentXL(): number;

        /**
         * Gets current value of property <code>linebreak</code>.Optional. If this property is set to true, the
         * control on all-size screens causes a line break within the Grid and becomes the first within the
         * next line.Default value is <code>false</code>.
         * @returns Value of property <code>linebreak</code>
        */
        getLinebreak(): boolean;

        /**
         * Gets current value of property <code>linebreakL</code>.Optional. If this property is set to true,
         * the control on large screens causes a line break within the Grid and becomes the first within the
         * next line.Default value is <code>false</code>.
         * @returns Value of property <code>linebreakL</code>
        */
        getLinebreakL(): boolean;

        /**
         * Gets current value of property <code>linebreakM</code>.Optional. If this property is set to true,
         * the control on medium sized screens causes a line break within the Grid and becomes the first within
         * the next line.Default value is <code>false</code>.
         * @returns Value of property <code>linebreakM</code>
        */
        getLinebreakM(): boolean;

        /**
         * Gets current value of property <code>linebreakS</code>.Optional. If this property is set to true,
         * the control on small screens causes a line break within the Grid and becomes the first within the
         * next line.Default value is <code>false</code>.
         * @returns Value of property <code>linebreakS</code>
        */
        getLinebreakS(): boolean;

        /**
         * Gets current value of property <code>linebreakXL</code>.Optional. If this property is set to true,
         * the control on extra large screens causes a line break within the Grid and becomes the first within
         * the next line.Default value is <code>false</code>.
         * @returns Value of property <code>linebreakXL</code>
        */
        getLinebreakXL(): boolean;

        /**
         * Returns a metadata object for class sap.ui.layout.GridData.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>moveBackwards</code>.Optional. Moves a cell backwards so many
         * columns as specified.
         * @returns Value of property <code>moveBackwards</code>
        */
        getMoveBackwards(): any;

        /**
         * Gets current value of property <code>moveForward</code>.Optional. Moves a cell forwards so many
         * columns as specified.
         * @returns Value of property <code>moveForward</code>
        */
        getMoveForward(): any;

        /**
         * Gets current value of property <code>span</code>.A string type that represents Grid's span values
         * for large, medium and small screens. Allowed values are separated by space Letters L, M or S
         * followed by number of columns from 1 to 12 that the container has to take, for example: "L2 M4 S6",
         * "M12", "s10" or "l4 m4". Note that the parameters has to be provided in the order large medium
         * small.
         * @returns Value of property <code>span</code>
        */
        getSpan(): any;

        /**
         * Gets current value of property <code>spanL</code>.Optional. Defines a span value for large screens.
         * This value overwrites the value for large screens defined in the parameter "span".
         * @returns Value of property <code>spanL</code>
        */
        getSpanL(): number;

        /**
         * Gets current value of property <code>spanLarge</code>.Deprecated. Defines a span value for large
         * screens. This value overwrites the value for large screens defined in the parameter "span".
         * @returns Value of property <code>spanLarge</code>
        */
        getSpanLarge(): number;

        /**
         * Gets current value of property <code>spanM</code>.Optional. Defines a span value for medium size
         * screens. This value overwrites the value for medium screens defined in the parameter "span".
         * @returns Value of property <code>spanM</code>
        */
        getSpanM(): number;

        /**
         * Gets current value of property <code>spanMedium</code>.Deprecated. Defines a span value for medium
         * size screens. This value overwrites the value for medium screens defined in the parameter "span".
         * @returns Value of property <code>spanMedium</code>
        */
        getSpanMedium(): number;

        /**
         * Gets current value of property <code>spanS</code>.Optional. Defines a span value for small screens.
         * This value overwrites the value for small screens defined in the parameter "span".
         * @returns Value of property <code>spanS</code>
        */
        getSpanS(): number;

        /**
         * Gets current value of property <code>spanSmall</code>.Deprecated. Defines a span value for small
         * screens. This value overwrites the value for small screens defined in the parameter "span".
         * @returns Value of property <code>spanSmall</code>
        */
        getSpanSmall(): number;

        /**
         * Gets current value of property <code>spanXL</code>.Optional. Defines a span value for extra large
         * screens. This value overwrites the value for extra large screens defined in the parameter "span".
         * @returns Value of property <code>spanXL</code>
        */
        getSpanXL(): number;

        /**
         * Gets current value of property <code>visibleL</code>.Defines if this Control is visible on Large
         * screens.Default value is <code>true</code>.
         * @returns Value of property <code>visibleL</code>
        */
        getVisibleL(): boolean;

        /**
         * Gets current value of property <code>visibleM</code>.Defines if this Control is visible on Medium
         * size screens.Default value is <code>true</code>.
         * @returns Value of property <code>visibleM</code>
        */
        getVisibleM(): boolean;

        /**
         * Gets current value of property <code>visibleOnLarge</code>.Deprecated. Defines if this Control is
         * visible on Large screens.Default value is <code>true</code>.
         * @returns Value of property <code>visibleOnLarge</code>
        */
        getVisibleOnLarge(): boolean;

        /**
         * Gets current value of property <code>visibleOnMedium</code>.Deprecated. Defines if this Control is
         * visible on Medium size screens.Default value is <code>true</code>.
         * @returns Value of property <code>visibleOnMedium</code>
        */
        getVisibleOnMedium(): boolean;

        /**
         * Gets current value of property <code>visibleOnSmall</code>.Deprecated. Defines if this Control is
         * visible on small screens.Default value is <code>true</code>.
         * @returns Value of property <code>visibleOnSmall</code>
        */
        getVisibleOnSmall(): boolean;

        /**
         * Gets current value of property <code>visibleS</code>.Defines if this Control is visible on small
         * screens.Default value is <code>true</code>.
         * @returns Value of property <code>visibleS</code>
        */
        getVisibleS(): boolean;

        /**
         * Gets current value of property <code>visibleXL</code>.Defines if this Control is visible on XL -
         * extra Large screens.Default value is <code>true</code>.
         * @returns Value of property <code>visibleXL</code>
        */
        getVisibleXL(): boolean;

        /**
         * Sets a new value for property <code>indent</code>.A string type that represents Grid's span values
         * for large, medium and small screens. Allowed values are separated by space Letters L, M or S
         * followed by number of columns from 1 to 12 that the container has to take, for example: "L2 M4 S6",
         * "M12", "s10" or "l4 m4". Note that the parameters has to be provided in the order large medium
         * small.When called with a value of <code>null</code> or <code>undefined</code>, the default value of
         * the property will be restored.
         * @param sIndent New value for property <code>indent</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setIndent(sIndent: any): sap.ui.layout.GridData;

        /**
         * Sets a new value for property <code>indentL</code>.Optional. Defines a span value for large screens.
         * This value overwrites the value for large screens defined in the parameter "indent".When called with
         * a value of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.
         * @param iIndentL New value for property <code>indentL</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setIndentL(iIndentL: number): sap.ui.layout.GridData;

        /**
         * Sets a new value for property <code>indentLarge</code>.Deprecated. Defines a span value for large
         * screens. This value overwrites the value for large screens defined in the parameter "indent".When
         * called with a value of <code>null</code> or <code>undefined</code>, the default value of the
         * property will be restored.
         * @param iIndentLarge New value for property <code>indentLarge</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setIndentLarge(iIndentLarge: number): sap.ui.layout.GridData;

        /**
         * Sets a new value for property <code>indentM</code>.Optional. Defines a span value for medium size
         * screens. This value overwrites the value for medium screens defined in the parameter "indent".When
         * called with a value of <code>null</code> or <code>undefined</code>, the default value of the
         * property will be restored.
         * @param iIndentM New value for property <code>indentM</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setIndentM(iIndentM: number): sap.ui.layout.GridData;

        /**
         * Sets a new value for property <code>indentMedium</code>.Deprecated. Defines a span value for medium
         * size screens. This value overwrites the value for medium screens defined in the parameter
         * "indent".When called with a value of <code>null</code> or <code>undefined</code>, the default value
         * of the property will be restored.
         * @param iIndentMedium New value for property <code>indentMedium</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setIndentMedium(iIndentMedium: number): sap.ui.layout.GridData;

        /**
         * Sets a new value for property <code>indentS</code>.Optional. Defines a span value for small screens.
         * This value overwrites the value for small screens defined in the parameter "indent".When called with
         * a value of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.
         * @param iIndentS New value for property <code>indentS</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setIndentS(iIndentS: number): sap.ui.layout.GridData;

        /**
         * Sets a new value for property <code>indentSmall</code>.Deprecated. Defines a span value for small
         * screens. This value overwrites the value for small screens defined in the parameter "indent".When
         * called with a value of <code>null</code> or <code>undefined</code>, the default value of the
         * property will be restored.
         * @param iIndentSmall New value for property <code>indentSmall</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setIndentSmall(iIndentSmall: number): sap.ui.layout.GridData;

        /**
         * Sets a new value for property <code>indentXL</code>.Optional. Defines a span value for extra large
         * screens. This value overwrites the value for extra large screens defined in the parameter
         * "indent".When called with a value of <code>null</code> or <code>undefined</code>, the default value
         * of the property will be restored.
         * @param iIndentXL New value for property <code>indentXL</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setIndentXL(iIndentXL: number): sap.ui.layout.GridData;

        /**
         * Sets a new value for property <code>linebreak</code>.Optional. If this property is set to true, the
         * control on all-size screens causes a line break within the Grid and becomes the first within the
         * next line.When called with a value of <code>null</code> or <code>undefined</code>, the default value
         * of the property will be restored.Default value is <code>false</code>.
         * @param bLinebreak New value for property <code>linebreak</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setLinebreak(bLinebreak: boolean): sap.ui.layout.GridData;

        /**
         * Sets a new value for property <code>linebreakL</code>.Optional. If this property is set to true, the
         * control on large screens causes a line break within the Grid and becomes the first within the next
         * line.When called with a value of <code>null</code> or <code>undefined</code>, the default value of
         * the property will be restored.Default value is <code>false</code>.
         * @param bLinebreakL New value for property <code>linebreakL</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setLinebreakL(bLinebreakL: boolean): sap.ui.layout.GridData;

        /**
         * Sets a new value for property <code>linebreakM</code>.Optional. If this property is set to true, the
         * control on medium sized screens causes a line break within the Grid and becomes the first within the
         * next line.When called with a value of <code>null</code> or <code>undefined</code>, the default value
         * of the property will be restored.Default value is <code>false</code>.
         * @param bLinebreakM New value for property <code>linebreakM</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setLinebreakM(bLinebreakM: boolean): sap.ui.layout.GridData;

        /**
         * Sets a new value for property <code>linebreakS</code>.Optional. If this property is set to true, the
         * control on small screens causes a line break within the Grid and becomes the first within the next
         * line.When called with a value of <code>null</code> or <code>undefined</code>, the default value of
         * the property will be restored.Default value is <code>false</code>.
         * @param bLinebreakS New value for property <code>linebreakS</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setLinebreakS(bLinebreakS: boolean): sap.ui.layout.GridData;

        /**
         * Sets a new value for property <code>linebreakXL</code>.Optional. If this property is set to true,
         * the control on extra large screens causes a line break within the Grid and becomes the first within
         * the next line.When called with a value of <code>null</code> or <code>undefined</code>, the default
         * value of the property will be restored.Default value is <code>false</code>.
         * @param bLinebreakXL New value for property <code>linebreakXL</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setLinebreakXL(bLinebreakXL: boolean): sap.ui.layout.GridData;

        /**
         * Sets a new value for property <code>moveBackwards</code>.Optional. Moves a cell backwards so many
         * columns as specified.When called with a value of <code>null</code> or <code>undefined</code>, the
         * default value of the property will be restored.
         * @param sMoveBackwards New value for property <code>moveBackwards</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setMoveBackwards(sMoveBackwards: any): sap.ui.layout.GridData;

        /**
         * Sets a new value for property <code>moveForward</code>.Optional. Moves a cell forwards so many
         * columns as specified.When called with a value of <code>null</code> or <code>undefined</code>, the
         * default value of the property will be restored.
         * @param sMoveForward New value for property <code>moveForward</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setMoveForward(sMoveForward: any): sap.ui.layout.GridData;

        /**
         * Sets a new value for property <code>span</code>.A string type that represents Grid's span values for
         * large, medium and small screens. Allowed values are separated by space Letters L, M or S followed by
         * number of columns from 1 to 12 that the container has to take, for example: "L2 M4 S6", "M12", "s10"
         * or "l4 m4". Note that the parameters has to be provided in the order large medium small.When called
         * with a value of <code>null</code> or <code>undefined</code>, the default value of the property will
         * be restored.
         * @param sSpan New value for property <code>span</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setSpan(sSpan: any): sap.ui.layout.GridData;

        /**
         * Sets a new value for property <code>spanL</code>.Optional. Defines a span value for large screens.
         * This value overwrites the value for large screens defined in the parameter "span".When called with a
         * value of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.
         * @param iSpanL New value for property <code>spanL</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setSpanL(iSpanL: number): sap.ui.layout.GridData;

        /**
         * Sets a new value for property <code>spanLarge</code>.Deprecated. Defines a span value for large
         * screens. This value overwrites the value for large screens defined in the parameter "span".When
         * called with a value of <code>null</code> or <code>undefined</code>, the default value of the
         * property will be restored.
         * @param iSpanLarge New value for property <code>spanLarge</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setSpanLarge(iSpanLarge: number): sap.ui.layout.GridData;

        /**
         * Sets a new value for property <code>spanM</code>.Optional. Defines a span value for medium size
         * screens. This value overwrites the value for medium screens defined in the parameter "span".When
         * called with a value of <code>null</code> or <code>undefined</code>, the default value of the
         * property will be restored.
         * @param iSpanM New value for property <code>spanM</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setSpanM(iSpanM: number): sap.ui.layout.GridData;

        /**
         * Sets a new value for property <code>spanMedium</code>.Deprecated. Defines a span value for medium
         * size screens. This value overwrites the value for medium screens defined in the parameter
         * "span".When called with a value of <code>null</code> or <code>undefined</code>, the default value of
         * the property will be restored.
         * @param iSpanMedium New value for property <code>spanMedium</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setSpanMedium(iSpanMedium: number): sap.ui.layout.GridData;

        /**
         * Sets a new value for property <code>spanS</code>.Optional. Defines a span value for small screens.
         * This value overwrites the value for small screens defined in the parameter "span".When called with a
         * value of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.
         * @param iSpanS New value for property <code>spanS</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setSpanS(iSpanS: number): sap.ui.layout.GridData;

        /**
         * Sets a new value for property <code>spanSmall</code>.Deprecated. Defines a span value for small
         * screens. This value overwrites the value for small screens defined in the parameter "span".When
         * called with a value of <code>null</code> or <code>undefined</code>, the default value of the
         * property will be restored.
         * @param iSpanSmall New value for property <code>spanSmall</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setSpanSmall(iSpanSmall: number): sap.ui.layout.GridData;

        /**
         * Sets a new value for property <code>spanXL</code>.Optional. Defines a span value for extra large
         * screens. This value overwrites the value for extra large screens defined in the parameter
         * "span".When called with a value of <code>null</code> or <code>undefined</code>, the default value of
         * the property will be restored.
         * @param iSpanXL New value for property <code>spanXL</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setSpanXL(iSpanXL: number): sap.ui.layout.GridData;

        /**
         * Sets a new value for property <code>visibleL</code>.Defines if this Control is visible on Large
         * screens.When called with a value of <code>null</code> or <code>undefined</code>, the default value
         * of the property will be restored.Default value is <code>true</code>.
         * @param bVisibleL New value for property <code>visibleL</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setVisibleL(bVisibleL: boolean): sap.ui.layout.GridData;

        /**
         * Sets a new value for property <code>visibleM</code>.Defines if this Control is visible on Medium
         * size screens.When called with a value of <code>null</code> or <code>undefined</code>, the default
         * value of the property will be restored.Default value is <code>true</code>.
         * @param bVisibleM New value for property <code>visibleM</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setVisibleM(bVisibleM: boolean): sap.ui.layout.GridData;

        /**
         * Sets a new value for property <code>visibleOnLarge</code>.Deprecated. Defines if this Control is
         * visible on Large screens.When called with a value of <code>null</code> or <code>undefined</code>,
         * the default value of the property will be restored.Default value is <code>true</code>.
         * @param bVisibleOnLarge New value for property <code>visibleOnLarge</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setVisibleOnLarge(bVisibleOnLarge: boolean): sap.ui.layout.GridData;

        /**
         * Sets a new value for property <code>visibleOnMedium</code>.Deprecated. Defines if this Control is
         * visible on Medium size screens.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.Default value is
         * <code>true</code>.
         * @param bVisibleOnMedium New value for property <code>visibleOnMedium</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setVisibleOnMedium(bVisibleOnMedium: boolean): sap.ui.layout.GridData;

        /**
         * Sets a new value for property <code>visibleOnSmall</code>.Deprecated. Defines if this Control is
         * visible on small screens.When called with a value of <code>null</code> or <code>undefined</code>,
         * the default value of the property will be restored.Default value is <code>true</code>.
         * @param bVisibleOnSmall New value for property <code>visibleOnSmall</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setVisibleOnSmall(bVisibleOnSmall: boolean): sap.ui.layout.GridData;

        /**
         * Sets a new value for property <code>visibleS</code>.Defines if this Control is visible on small
         * screens.When called with a value of <code>null</code> or <code>undefined</code>, the default value
         * of the property will be restored.Default value is <code>true</code>.
         * @param bVisibleS New value for property <code>visibleS</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setVisibleS(bVisibleS: boolean): sap.ui.layout.GridData;

        /**
         * Sets a new value for property <code>visibleXL</code>.Defines if this Control is visible on XL -
         * extra Large screens.When called with a value of <code>null</code> or <code>undefined</code>, the
         * default value of the property will be restored.Default value is <code>true</code>.
         * @param bVisibleXL New value for property <code>visibleXL</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setVisibleXL(bVisibleXL: boolean): sap.ui.layout.GridData;
      }
      /**
       * A layout that contains several content areas. The content that is added to the splitter should
       * contain LayoutData of the type SplitterLayoutData that defines its size and size contraints.By
       * adding or changing SplitterLayoutData to the controls that make up the content areas, the size can
       * be changed programatically. Additionally the contents can be made non-resizable individually and a
       * minimal size (in px) can be set.The orientation of the splitter can be set to horizontal (default)
       * or vertical. All content areas of the splitter will be arranged in that way. In order to split
       * vertically and horizontally at the same time, Splitters need to be nested.The splitter bars can be
       * focused to enable resizing of the content areas via keyboard. The contents size can be manipulated
       * when the splitter bar is focused and Shift-Left/Down/Right/Up are pressed. When Shift-Home/End are
       * pressed, the contents are set their minimum or maximum size (keep in mind though, that resizing an
       * auto-size content-area next to another auto-size one might lead to the effect that the former does
       * not take its maximum size but only the maximum size before recalculating auto sizes).The splitter
       * bars used for resizing the contents by the user can be set to different widths (or heights in
       * vertical mode) and the splitter will automatically resize the other contents accordingly. In case
       * the splitter bar is resized after the splitter has rendered, a manual resize has to be triggered by
       * invoking triggerResize() on the Splitter.
       * @resource sap/ui/layout/Splitter.js
      */
      export class Splitter extends sap.ui.core.Control {


        /**
         * Constructor for a new Splitter.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Adds some contentArea to the aggregation <code>contentAreas</code>.
         * @param oContentArea the contentArea to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addContentArea(oContentArea: sap.ui.core.Control): sap.ui.layout.Splitter;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>resize</code> event of this
         * <code>sap.ui.layout.Splitter</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.layout.Splitter</code> itself.Event is fired when contents are resized.
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.layout.Splitter</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachResize(oData: any, fnFunction: any, oListener?: any): sap.ui.layout.Splitter;

        /**
         * Destroys all the contentAreas in the aggregation <code>contentAreas</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyContentAreas(): sap.ui.layout.Splitter;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>resize</code> event of this
         * <code>sap.ui.layout.Splitter</code>.The passed function and listener object must match the ones used
         * for event registration.
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachResize(fnFunction: any, oListener: any): sap.ui.layout.Splitter;

        /**
         * Disables the resize handler for this control, this leads to an automatic resize ofthe contents
         * whenever the control changes its size. The resize handler is enabledin every control instance by
         * default.For performance reasons this behavior can be disabled by calling disableAutoResize()
         * @param bTemporarily Only disable autoResize temporarily (used for live resize), so that the previous
         * status can be restored afterwards
        */
        disableAutoResize(bTemporarily: boolean): void;

        /**
         * Disables the resizing of the Splitter contents via keyboard. This changes the Splitter barsto
         * non-focussable elements.
        */
        disableKeyboardSupport(): void;

        /**
         * Disables recalculation and resize of the splitter contents while dragging the splitter bar.This
         * means that the contents are resized only once after moving the splitter bar.
        */
        disableLiveResize(): void;

        /**
         * Enables the resize handler for this control, this leads to an automatic resize ofthe contents
         * whenever the control changes its size. The resize handler is enabledin every control instance by
         * default.For performance reasons this behavior can be disabled by calling disableAutoResize()
         * @param bTemporarily Only enables autoResize if it was previously disabled temporarily (used for live
         * resize)
        */
        enableAutoResize(bTemporarily: boolean): void;

        /**
         * Enables the resizing of the Splitter contents via keyboard. This makes the Splitter barsfocussable
         * elements.
        */
        enableKeyboardSupport(): void;

        /**
         * Enables recalculation and resize of the splitter contents while dragging the splitter bar.This means
         * that the contents are resized several times per second when moving the splitter bar.
        */
        enableLiveResize(): void;


        /**
         * Fires event <code>resize</code> to attached listeners.Expects the following event
         * parameters:<ul><li><code>id</code> of type <code>string</code>The ID of the splitter control. The
         * splitter control can also be accessed by calling getSource() on the
         * event.</li><li><code>oldSizes</code> of type <code>int[]</code>An array of values representing the
         * old (pixel-)sizes of the splitter contents</li><li><code>newSizes</code> of type
         * <code>int[]</code>An array of values representing the new (pixel-)sizes of the splitter
         * contents</li></ul>
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireResize(mArguments: any): sap.ui.layout.Splitter;

        /**
         * Returns the current actual content sizes as pixel value - these values can change with everyresize.
         * @returns Array of px values that correspond to the content area sizes
        */
        getCalculatedSizes(): Number[];

        /**
         * Gets content of aggregation <code>contentAreas</code>.The content areas to be split. The control
         * will show n-1 splitter bars between n controls in this aggregation.
        */
        getContentAreas(): sap.ui.core.Control[];

        /**
         * Gets current value of property <code>height</code>.The height of the controlDefault value is
         * <code>100%</code>.
         * @returns Value of property <code>height</code>
        */
        getHeight(): any;

        /**
         * Returns a metadata object for class sap.ui.layout.Splitter.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>orientation</code>.Whether to split the contents horizontally
         * (default) or vertically.Default value is <code>Horizontal</code>.
         * @returns Value of property <code>orientation</code>
        */
        getOrientation(): sap.ui.core.Orientation;

        /**
         * Gets current value of property <code>width</code>.The width of the controlDefault value is
         * <code>100%</code>.
         * @returns Value of property <code>width</code>
        */
        getWidth(): any;

        /**
         * Checks for the provided <code>sap.ui.core.Control</code> in the aggregation
         * <code>contentAreas</code>.and returns its index if found or -1 otherwise.
         * @param oContentArea The contentArea whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfContentArea(oContentArea: sap.ui.core.Control): number;

        /**
         * Inserts a contentArea into the aggregation <code>contentAreas</code>.
         * @param oContentArea the contentArea to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the contentArea should be inserted at; for            
         * a negative value of <code>iIndex</code>, the contentArea is inserted at position 0; for a value     
         *        greater than the current size of the aggregation, the contentArea is inserted at            
         * the last position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertContentArea(oContentArea: sap.ui.core.Control, iIndex: number): sap.ui.layout.Splitter;

        /**
         * Removes all the controls from the aggregation <code>contentAreas</code>.Additionally, it unregisters
         * them from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllContentAreas(): sap.ui.core.Control[];

        /**
         * Removes a contentArea from the aggregation <code>contentAreas</code>.
         * @param vContentArea The contentArea to remove or its index or id
         * @returns The removed contentArea or <code>null</code>
        */
        removeContentArea(vContentArea: number | string | sap.ui.core.Control): sap.ui.core.Control;

        /**
         * Sets a new value for property <code>height</code>.The height of the controlWhen called with a value
         * of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>100%</code>.
         * @param sHeight New value for property <code>height</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setHeight(sHeight: any): sap.ui.layout.Splitter;

        /**
         * Sets a new value for property <code>orientation</code>.Whether to split the contents horizontally
         * (default) or vertically.When called with a value of <code>null</code> or <code>undefined</code>, the
         * default value of the property will be restored.Default value is <code>Horizontal</code>.
         * @param sOrientation New value for property <code>orientation</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setOrientation(sOrientation: sap.ui.core.Orientation): sap.ui.layout.Splitter;

        /**
         * Sets a new value for property <code>width</code>.The width of the controlWhen called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>100%</code>.
         * @param sWidth New value for property <code>width</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setWidth(sWidth: any): sap.ui.layout.Splitter;

        /**
         * This method  triggers a resize on the Splitter - meaning it forces the Splitter to recalculateall
         * sizes.This method should only be used in rare cases, for example when the CSS that defines the
         * sizesof the splitter bars changes without triggering a rerendering of the splitter.
         * @param forceDirectly Do not delay the resize, trigger it right now.
        */
        triggerResize(forceDirectly: boolean): void;
      }
      /**
       * SplitPane is a container of a single control.Could be used as an aggregation of a PaneContainer.
       * @resource sap/ui/layout/SplitPane.js
      */
      export class SplitPane extends sap.ui.core.Element {


        /**
         * Constructor for a new SplitPane.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId ID for the new control, generated automatically if no ID is given
         * @param mSettings Initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Destroys the content in the aggregation <code>content</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyContent(): sap.ui.layout.SplitPane;


        /**
         * Gets content of aggregation <code>content</code>.Content of the SplitPane
        */
        getContent(): sap.ui.core.Control;

        /**
         * Gets current value of property <code>demandPane</code>.Determines whether the pane will be moved to
         * the paginationDefault value is <code>true</code>.
         * @returns Value of property <code>demandPane</code>
        */
        getDemandPane(): boolean;

        /**
         * Returns a metadata object for class sap.ui.layout.SplitPane.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>requiredParentWidth</code>.Determines the minimum width of the
         * ResponsiveSplitter(in pixels). When it is reached the pane will be hidden from the screen.Default
         * value is <code>800</code>.
         * @returns Value of property <code>requiredParentWidth</code>
        */
        getRequiredParentWidth(): number;

        /**
         * Sets the aggregated <code>content</code>.
         * @param oContent The content to set
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setContent(oContent: sap.ui.core.Control): sap.ui.layout.SplitPane;

        /**
         * Sets a new value for property <code>demandPane</code>.Determines whether the pane will be moved to
         * the paginationWhen called with a value of <code>null</code> or <code>undefined</code>, the default
         * value of the property will be restored.Default value is <code>true</code>.
         * @param bDemandPane New value for property <code>demandPane</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setDemandPane(bDemandPane: boolean): sap.ui.layout.SplitPane;

        /**
         * Sets a new value for property <code>requiredParentWidth</code>.Determines the minimum width of the
         * ResponsiveSplitter(in pixels). When it is reached the pane will be hidden from the screen.When
         * called with a value of <code>null</code> or <code>undefined</code>, the default value of the
         * property will be restored.Default value is <code>800</code>.
         * @param iRequiredParentWidth New value for property <code>requiredParentWidth</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setRequiredParentWidth(iRequiredParentWidth: number): sap.ui.layout.SplitPane;
      }
      /**
       * The BlockLayout is used to display several objects in a section-based manner. It features horizontal
       * and vertical subdivisions, and full-width banners seen frequently in contemporary web design.
       * Background colors are attached directly to these “blocks” of the layout. Special full-width sections
       * of the BlockLayout allow horizontal scrolling through a set of blocks.Example use cases are SAP HANA
       * Cloud Integration and the SAPUI5 Demo Kit. In SAP HANA Cloud Integration the BlockLayout serves as a
       * banner-like presentation of illustrative icons with associated text. By placing pictorial and
       * textual elements side by side in different blocks, a relation of content is established. In the
       * SAPUI5 Demo Kit the BlockLayout serves as a flexible container for diverging content, such as
       * headings, explanatory texts, code snippets, remarks, and examples.The BlockLayout comes in three
       * types: Layout only (default), Bright, and Mixed background colors.
       * @resource sap/ui/layout/BlockLayout.js
      */
      export class BlockLayout extends sap.ui.core.Control {


        /**
         * Constructor for a new BlockLayout.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId ID for the new control, generated automatically if no ID is given
         * @param mSettings Initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Adds some content to the aggregation <code>content</code>.
         * @param oContent the content to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addContent(oContent: sap.ui.layout.BlockLayoutRow): sap.ui.layout.BlockLayout;

        /**
         * Destroys all the content in the aggregation <code>content</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyContent(): sap.ui.layout.BlockLayout;


        /**
         * Gets current value of property <code>background</code>.Determines the background used for the
         * LayoutDefault value is <code>Default</code>.
         * @returns Value of property <code>background</code>
        */
        getBackground(): typeof sap.ui.layout.BlockBackgroundType;

        /**
         * Gets content of aggregation <code>content</code>.The Rows to be included in the content of the
         * control
        */
        getContent(): sap.ui.layout.BlockLayoutRow[];

        /**
         * Returns a metadata object for class sap.ui.layout.BlockLayout.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Checks for the provided <code>sap.ui.layout.BlockLayoutRow</code> in the aggregation
         * <code>content</code>.and returns its index if found or -1 otherwise.
         * @param oContent The content whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfContent(oContent: sap.ui.layout.BlockLayoutRow): number;

        /**
         * Inserts a content into the aggregation <code>content</code>.
         * @param oContent the content to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the content should be inserted at; for             a
         * negative value of <code>iIndex</code>, the content is inserted at position 0; for a value           
         *  greater than the current size of the aggregation, the content is inserted at             the last
         * position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertContent(oContent: sap.ui.layout.BlockLayoutRow, iIndex: number): sap.ui.layout.BlockLayout;

        /**
         * Removes all the controls from the aggregation <code>content</code>.Additionally, it unregisters them
         * from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllContent(): sap.ui.layout.BlockLayoutRow[];

        /**
         * Removes a content from the aggregation <code>content</code>.
         * @param vContent The content to remove or its index or id
         * @returns The removed content or <code>null</code>
        */
        removeContent(vContent: number | string | sap.ui.layout.BlockLayoutRow): sap.ui.layout.BlockLayoutRow;

        /**
         * Sets a new value for property <code>background</code>.Determines the background used for the
         * LayoutWhen called with a value of <code>null</code> or <code>undefined</code>, the default value of
         * the property will be restored.Default value is <code>Default</code>.
         * @param sBackground New value for property <code>background</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setBackground(sBackground: typeof sap.ui.layout.BlockBackgroundType): sap.ui.layout.BlockLayout;
      }
      /**
       * PaneContainer is an abstraction of SplitterCould be used as an aggregation of ResponsiveSplitter or
       * other PaneContainers.
       * @resource sap/ui/layout/PaneContainer.js
      */
      export class PaneContainer extends sap.ui.core.Element {


        /**
         * Constructor for a new PaneContainer.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId ID for the new control, generated automatically if no ID is given
         * @param mSettings Initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Adds some pane to the aggregation <code>panes</code>.
         * @param oPane the pane to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addPane(oPane: sap.ui.core.Element): sap.ui.layout.PaneContainer;

        /**
         * Destroys all the panes in the aggregation <code>panes</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyPanes(): sap.ui.layout.PaneContainer;


        /**
         * Returns a metadata object for class sap.ui.layout.PaneContainer.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>orientation</code>.The orientation of the SplitterDefault value
         * is <code>Horizontal</code>.
         * @returns Value of property <code>orientation</code>
        */
        getOrientation(): sap.ui.core.Orientation;

        /**
         * Gets content of aggregation <code>panes</code>.The Pane that will be shown when there is no suitable
         * pane for ResponsiveSplitter's current width.
        */
        getPanes(): sap.ui.core.Element[];

        /**
         * Checks for the provided <code>sap.ui.core.Element</code> in the aggregation <code>panes</code>.and
         * returns its index if found or -1 otherwise.
         * @param oPane The pane whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfPane(oPane: sap.ui.core.Element): number;

        /**
         * Inserts a pane into the aggregation <code>panes</code>.
         * @param oPane the pane to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the pane should be inserted at; for             a
         * negative value of <code>iIndex</code>, the pane is inserted at position 0; for a value            
         * greater than the current size of the aggregation, the pane is inserted at             the last
         * position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertPane(oPane: sap.ui.core.Element, iIndex: number): sap.ui.layout.PaneContainer;

        /**
         * Removes all the controls from the aggregation <code>panes</code>.Additionally, it unregisters them
         * from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllPanes(): sap.ui.core.Element[];

        /**
         * Removes a pane from the aggregation <code>panes</code>.
         * @param vPane The pane to remove or its index or id
         * @returns The removed pane or <code>null</code>
        */
        removePane(vPane: number | string | sap.ui.core.Element): sap.ui.core.Element;

        /**
         * Setter for property layoutData.
         * @param oLayoutData The LayoutData object.
         * @returns this to allow method chaining.
        */
        setLayoutData(oLayoutData: sap.ui.core.LayoutData): sap.ui.layout.PaneContainer;

        /**
         * Setter for property orientation.Default value is sap.ui.core.Orientation.Horizontal
         * @param sOrientation The Orientation type.
         * @returns this to allow method chaining.
        */
        setOrientation(sOrientation: sap.ui.core.Orientation): sap.ui.layout.PaneContainer;
      }
      /**
       * The BlockLayoutRow is used as an aggregation to the BlockLayout. It aggregates Block Layout 
       * cells.The BlockLayoutRow has 2 rendering modes - scrollable and non scrollable.
       * @resource sap/ui/layout/BlockLayoutRow.js
      */
      export class BlockLayoutRow extends sap.ui.core.Control {


        /**
         * Constructor for a new BlockLayoutRow.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId ID for the new control, generated automatically if no ID is given
         * @param mSettings Initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Adds some content to the aggregation <code>content</code>.
         * @param oContent the content to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addContent(oContent: sap.ui.layout.BlockLayoutCell): sap.ui.layout.BlockLayoutRow;

        /**
         * Destroys all the content in the aggregation <code>content</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyContent(): sap.ui.layout.BlockLayoutRow;


        /**
         * Gets content of aggregation <code>content</code>.The content cells to be included in the row.
        */
        getContent(): sap.ui.layout.BlockLayoutCell[];

        /**
         * Returns a metadata object for class sap.ui.layout.BlockLayoutRow.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>scrollable</code>.Sets the rendering mode of the BlockLayoutRow
         * to scrollable. In scrollable mode, the cells getaligned side by side, with horizontal scroll bar for
         * the row.Default value is <code>false</code>.
         * @returns Value of property <code>scrollable</code>
        */
        getScrollable(): boolean;

        /**
         * Checks for the provided <code>sap.ui.layout.BlockLayoutCell</code> in the aggregation
         * <code>content</code>.and returns its index if found or -1 otherwise.
         * @param oContent The content whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfContent(oContent: sap.ui.layout.BlockLayoutCell): number;

        /**
         * Inserts a content into the aggregation <code>content</code>.
         * @param oContent the content to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the content should be inserted at; for             a
         * negative value of <code>iIndex</code>, the content is inserted at position 0; for a value           
         *  greater than the current size of the aggregation, the content is inserted at             the last
         * position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertContent(oContent: sap.ui.layout.BlockLayoutCell, iIndex: number): sap.ui.layout.BlockLayoutRow;

        /**
         * Removes all the controls from the aggregation <code>content</code>.Additionally, it unregisters them
         * from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllContent(): sap.ui.layout.BlockLayoutCell[];

        /**
         * Removes a content from the aggregation <code>content</code>.
         * @param vContent The content to remove or its index or id
         * @returns The removed content or <code>null</code>
        */
        removeContent(vContent: number | string | sap.ui.layout.BlockLayoutCell): sap.ui.layout.BlockLayoutCell;

        /**
         * Sets a new value for property <code>scrollable</code>.Sets the rendering mode of the BlockLayoutRow
         * to scrollable. In scrollable mode, the cells getaligned side by side, with horizontal scroll bar for
         * the row.When called with a value of <code>null</code> or <code>undefined</code>, the default value
         * of the property will be restored.Default value is <code>false</code>.
         * @param bScrollable New value for property <code>scrollable</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setScrollable(bScrollable: boolean): sap.ui.layout.BlockLayoutRow;
      }
      /**
       * In this layout the content controls are rendered one below the other.
       * @resource sap/ui/layout/VerticalLayout.js
      */
      export class VerticalLayout extends sap.ui.core.Control {


        /**
         * Constructor for a new VerticalLayout.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId Id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Adds some content to the aggregation <code>content</code>.
         * @param oContent the content to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addContent(oContent: sap.ui.core.Control): sap.ui.layout.VerticalLayout;

        /**
         * Destroys all the content in the aggregation <code>content</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyContent(): sap.ui.layout.VerticalLayout;


        /**
        */
        getAccessibilityInfo(): void;

        /**
         * Gets content of aggregation <code>content</code>.Content controls within the layout.
        */
        getContent(): sap.ui.core.Control[];

        /**
         * Gets current value of property <code>enabled</code>.If not enabled, all controls inside are not
         * enabled automatically.Default value is <code>true</code>.
         * @returns Value of property <code>enabled</code>
        */
        getEnabled(): boolean;

        /**
         * Returns a metadata object for class sap.ui.layout.VerticalLayout.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>width</code>.Width of the <code>VerticalLayout</code>. If no
         * width is set, the width of the content is used.If the content of the layout has a larger width than
         * the layout, it is cut off.There is no scrolling inside the layout.
         * @returns Value of property <code>width</code>
        */
        getWidth(): any;

        /**
         * Checks for the provided <code>sap.ui.core.Control</code> in the aggregation <code>content</code>.and
         * returns its index if found or -1 otherwise.
         * @param oContent The content whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfContent(oContent: sap.ui.core.Control): number;

        /**
         * Inserts a content into the aggregation <code>content</code>.
         * @param oContent the content to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the content should be inserted at; for             a
         * negative value of <code>iIndex</code>, the content is inserted at position 0; for a value           
         *  greater than the current size of the aggregation, the content is inserted at             the last
         * position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertContent(oContent: sap.ui.core.Control, iIndex: number): sap.ui.layout.VerticalLayout;

        /**
         * Removes all the controls from the aggregation <code>content</code>.Additionally, it unregisters them
         * from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllContent(): sap.ui.core.Control[];

        /**
         * Removes a content from the aggregation <code>content</code>.
         * @param vContent The content to remove or its index or id
         * @returns The removed content or <code>null</code>
        */
        removeContent(vContent: number | string | sap.ui.core.Control): sap.ui.core.Control;

        /**
         * Sets a new value for property <code>enabled</code>.If not enabled, all controls inside are not
         * enabled automatically.When called with a value of <code>null</code> or <code>undefined</code>, the
         * default value of the property will be restored.Default value is <code>true</code>.
         * @param bEnabled New value for property <code>enabled</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setEnabled(bEnabled: boolean): sap.ui.layout.VerticalLayout;
      }
      /**
       * The BlockLayoutCell is used as an aggregation of the BlockLayoutRow. It contains Controls.The
       * BlockLayoutCell should be used only as aggregation of the BlockLayoutRow.
       * @resource sap/ui/layout/BlockLayoutCell.js
      */
      export class BlockLayoutCell extends sap.ui.core.Control {


        /**
         * Constructor for a new BlockLayoutCell.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId ID for the new control, generated automatically if no ID is given
         * @param mSettings Initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Adds some content to the aggregation <code>content</code>.
         * @param oContent the content to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addContent(oContent: sap.ui.core.Control): sap.ui.layout.BlockLayoutCell;

        /**
         * Destroys all the content in the aggregation <code>content</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyContent(): sap.ui.layout.BlockLayoutCell;


        /**
         * Gets content of aggregation <code>content</code>.The content to be included inside the cell
        */
        getContent(): sap.ui.core.Control[];

        /**
         * Returns a metadata object for class sap.ui.layout.BlockLayoutCell.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>title</code>.Defines the title of the cell
         * @returns Value of property <code>title</code>
        */
        getTitle(): string;

        /**
         * Gets current value of property <code>titleAlignment</code>.Defines the alignment of the cell
         * titleDefault value is <code>Begin</code>.
         * @returns Value of property <code>titleAlignment</code>
        */
        getTitleAlignment(): sap.ui.core.HorizontalAlign;

        /**
         * Gets current value of property <code>titleLevel</code>.Defines the aria level of the titleThis
         * information is e.g. used by assistive technologies like screenreaders to create a hierarchical site
         * map for faster navigation.Default value is <code>Auto</code>.
         * @returns Value of property <code>titleLevel</code>
        */
        getTitleLevel(): sap.ui.core.TitleLevel;

        /**
         * Gets current value of property <code>width</code>.Defines the width of the cell. Depending on the
         * context of the cell - whether it's in scrollable,or non scrollable row, this property is interpreted
         * in two different ways.If the cell is placed inside a scrollable row - this property defines the
         * width of the cell inpercentages. If no value is provided - the default is 40%.If the cell is placed
         * inside a non scrollable row - this property defines the grow factor of the cellcompared to the whole
         * row.<b>For example:</b> If you have 2 cells, each with width of 1, this means that they should be of
         * equal size,and they need to fill the whole row. This results in 50% width for each cell. If you have
         * 2 cells,one with width of 1, the other with width of 3, this means that the whole row width is 4, so
         * the firstcell will have a width of 25%, the second - 75%.According to the visual guidelines, it is
         * suggested that you only use 25%, 50%, 75% or 100% cells inyou applications. For example, 12,5% width
         * is not desirable (1 cell with width 1, and another with width 7)Default value is <code>0</code>.
         * @returns Value of property <code>width</code>
        */
        getWidth(): number;

        /**
         * Checks for the provided <code>sap.ui.core.Control</code> in the aggregation <code>content</code>.and
         * returns its index if found or -1 otherwise.
         * @param oContent The content whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfContent(oContent: sap.ui.core.Control): number;

        /**
         * Inserts a content into the aggregation <code>content</code>.
         * @param oContent the content to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the content should be inserted at; for             a
         * negative value of <code>iIndex</code>, the content is inserted at position 0; for a value           
         *  greater than the current size of the aggregation, the content is inserted at             the last
         * position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertContent(oContent: sap.ui.core.Control, iIndex: number): sap.ui.layout.BlockLayoutCell;

        /**
         * Removes all the controls from the aggregation <code>content</code>.Additionally, it unregisters them
         * from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllContent(): sap.ui.core.Control[];

        /**
         * Removes a content from the aggregation <code>content</code>.
         * @param vContent The content to remove or its index or id
         * @returns The removed content or <code>null</code>
        */
        removeContent(vContent: number | string | sap.ui.core.Control): sap.ui.core.Control;

        /**
         * Sets a new value for property <code>title</code>.Defines the title of the cellWhen called with a
         * value of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.
         * @param sTitle New value for property <code>title</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setTitle(sTitle: string): sap.ui.layout.BlockLayoutCell;

        /**
         * Sets a new value for property <code>titleAlignment</code>.Defines the alignment of the cell
         * titleWhen called with a value of <code>null</code> or <code>undefined</code>, the default value of
         * the property will be restored.Default value is <code>Begin</code>.
         * @param sTitleAlignment New value for property <code>titleAlignment</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setTitleAlignment(sTitleAlignment: sap.ui.core.HorizontalAlign): sap.ui.layout.BlockLayoutCell;

        /**
         * Sets a new value for property <code>titleLevel</code>.Defines the aria level of the titleThis
         * information is e.g. used by assistive technologies like screenreaders to create a hierarchical site
         * map for faster navigation.When called with a value of <code>null</code> or <code>undefined</code>,
         * the default value of the property will be restored.Default value is <code>Auto</code>.
         * @param sTitleLevel New value for property <code>titleLevel</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setTitleLevel(sTitleLevel: sap.ui.core.TitleLevel): sap.ui.layout.BlockLayoutCell;
      }
      /**
       * A layout that provides support for horizontal alignment of controls
       * @resource sap/ui/layout/HorizontalLayout.js
      */
      export class HorizontalLayout extends sap.ui.core.Control {


        /**
         * Constructor for a new HorizontalLayout.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Adds some content to the aggregation <code>content</code>.
         * @param oContent the content to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addContent(oContent: sap.ui.core.Control): sap.ui.layout.HorizontalLayout;

        /**
         * Destroys all the content in the aggregation <code>content</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyContent(): sap.ui.layout.HorizontalLayout;


        /**
        */
        getAccessibilityInfo(): void;

        /**
         * Gets current value of property <code>allowWrapping</code>.Specifies whether the content inside the
         * Layout shall be line-wrapped in the case that there is less horizontal space available than
         * required.Default value is <code>false</code>.
         * @returns Value of property <code>allowWrapping</code>
        */
        getAllowWrapping(): boolean;

        /**
         * Gets content of aggregation <code>content</code>.The controls inside this layout
        */
        getContent(): sap.ui.core.Control[];

        /**
         * Returns a metadata object for class sap.ui.layout.HorizontalLayout.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Checks for the provided <code>sap.ui.core.Control</code> in the aggregation <code>content</code>.and
         * returns its index if found or -1 otherwise.
         * @param oContent The content whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfContent(oContent: sap.ui.core.Control): number;

        /**
         * Inserts a content into the aggregation <code>content</code>.
         * @param oContent the content to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the content should be inserted at; for             a
         * negative value of <code>iIndex</code>, the content is inserted at position 0; for a value           
         *  greater than the current size of the aggregation, the content is inserted at             the last
         * position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertContent(oContent: sap.ui.core.Control, iIndex: number): sap.ui.layout.HorizontalLayout;

        /**
         * Removes all the controls from the aggregation <code>content</code>.Additionally, it unregisters them
         * from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllContent(): sap.ui.core.Control[];

        /**
         * Removes a content from the aggregation <code>content</code>.
         * @param vContent The content to remove or its index or id
         * @returns The removed content or <code>null</code>
        */
        removeContent(vContent: number | string | sap.ui.core.Control): sap.ui.core.Control;

        /**
         * Sets a new value for property <code>allowWrapping</code>.Specifies whether the content inside the
         * Layout shall be line-wrapped in the case that there is less horizontal space available than
         * required.When called with a value of <code>null</code> or <code>undefined</code>, the default value
         * of the property will be restored.Default value is <code>false</code>.
         * @param bAllowWrapping New value for property <code>allowWrapping</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setAllowWrapping(bAllowWrapping: boolean): sap.ui.layout.HorizontalLayout;
      }
      /**
       * The DynamicSideContent control allows additional (side) content to be displayed alongside or below
       * the maincontent, within the container the control is used in. There are different size ratios
       * between the main andthe side content for the different breakpoints. The side content position
       * (alongside/below the main content)and visibility (visible/hidden) can be configured per breakpoint.
       * There are 4 predefined breakpoints:- Screen width > 1440 px (XL breakpoint)- Screen width <= 1440 px
       * (L breakpoint)- Main content width <= 600 px (M breakpoint)- Screen width <= 720 px (S breakpoint)
       * @resource sap/ui/layout/DynamicSideContent.js
      */
      export class DynamicSideContent extends sap.ui.core.Control {


        /**
         * Constructor for a new DynamicSideContent.Accepts an object literal <code>mSettings</code> that
         * defines initialproperty values, aggregated and associated objects as well as event handlers.See
         * {@link sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the
         * settings object.
         * @param sId ID for the new control, generated automatically if no ID is given
         * @param mSettings Initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Adds a control to the main content area.Only the main content part in the aggregation is
         * re-rendered.
         * @param oControl Object to be added in the aggregation
         * @returns this pointer for chaining
        */
        addMainContent(oControl: any): any;

        /**
         * Adds a control to the side content area.Only the side content part in the aggregation is
         * re-rendered.
         * @param oControl Object to be added in the aggregation
         * @returns this pointer for chaining
        */
        addSideContent(oControl: any): any;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>breakpointChanged</code> event of this
         * <code>sap.ui.layout.DynamicSideContent</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.layout.DynamicSideContent</code> itself.Fires when the current breakpoint has
         * been changed.
         * @since 1.32
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.layout.DynamicSideContent</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachBreakpointChanged(oData: any, fnFunction: any, oListener?: any): sap.ui.layout.DynamicSideContent;

        /**
         * Destroys all the mainContent in the aggregation <code>mainContent</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyMainContent(): sap.ui.layout.DynamicSideContent;

        /**
         * Destroys all the sideContent in the aggregation <code>sideContent</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroySideContent(): sap.ui.layout.DynamicSideContent;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>breakpointChanged</code> event of this
         * <code>sap.ui.layout.DynamicSideContent</code>.The passed function and listener object must match the
         * ones used for event registration.
         * @since 1.32
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachBreakpointChanged(fnFunction: any, oListener: any): sap.ui.layout.DynamicSideContent;


        /**
         * Fires event <code>breakpointChanged</code> to attached listeners.Expects the following event
         * parameters:<ul><li><code>currentBreakpoint</code> of type <code>string</code></li></ul>
         * @since 1.32
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireBreakpointChanged(mArguments: any): sap.ui.layout.DynamicSideContent;

        /**
         * Gets current value of property <code>containerQuery</code>.If set to TRUE, then not the media Query
         * (device screen size) but the size of the container, surrounding the control, defines the current
         * range.Default value is <code>false</code>.
         * @returns Value of property <code>containerQuery</code>
        */
        getContainerQuery(): boolean;

        /**
         * Returns the breakpoint for the current state of the control.
         * @returns currentBreakpoint
        */
        getCurrentBreakpoint(): String;

        /**
         * Gets current value of property <code>equalSplit</code>.Defines whether the control is in equal split
         * mode. In this mode, the side and the main contenttake 50:50 percent of the container on all screen
         * sizes except for phone, where the main andside contents are switching visibility using the toggle
         * method.Default value is <code>false</code>.
         * @returns Value of property <code>equalSplit</code>
        */
        getEqualSplit(): boolean;

        /**
         * Gets content of aggregation <code>mainContent</code>.Main content controls.
        */
        getMainContent(): sap.ui.core.Control[];

        /**
         * Returns a metadata object for class sap.ui.layout.DynamicSideContent.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets the value of showMainContent property.
         * @returns Side content visibility state
        */
        getShowMainContent(): boolean;

        /**
         * Gets the value of showSideContent property.
         * @returns Side content visibility state
        */
        getShowSideContent(): boolean;

        /**
         * Gets content of aggregation <code>sideContent</code>.Side content controls.
        */
        getSideContent(): sap.ui.core.Control[];

        /**
         * Gets current value of property <code>sideContentFallDown</code>.Determines on which breakpoints the
         * side content falls down below the main content.Default value is <code>OnMinimumWidth</code>.
         * @returns Value of property <code>sideContentFallDown</code>
        */
        getSideContentFallDown(): sap.ui.layout.SideContentFallDown;

        /**
         * Gets current value of property <code>sideContentPosition</code>.Determines whether the side content
         * is on the left or on the right side of the main content.Default value is <code>End</code>.
         * @since 1.36
         * @returns Value of property <code>sideContentPosition</code>
        */
        getSideContentPosition(): sap.ui.layout.SideContentPosition;

        /**
         * Gets current value of property <code>sideContentVisibility</code>.Determines on which breakpoints
         * the side content is visible.Default value is <code>ShowAboveS</code>.
         * @returns Value of property <code>sideContentVisibility</code>
        */
        getSideContentVisibility(): sap.ui.layout.SideContentVisibility;

        /**
         * Checks for the provided <code>sap.ui.core.Control</code> in the aggregation
         * <code>mainContent</code>.and returns its index if found or -1 otherwise.
         * @param oMainContent The mainContent whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfMainContent(oMainContent: sap.ui.core.Control): number;

        /**
         * Checks for the provided <code>sap.ui.core.Control</code> in the aggregation
         * <code>sideContent</code>.and returns its index if found or -1 otherwise.
         * @param oSideContent The sideContent whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfSideContent(oSideContent: sap.ui.core.Control): number;

        /**
         * Inserts a mainContent into the aggregation <code>mainContent</code>.
         * @param oMainContent the mainContent to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the mainContent should be inserted at; for            
         * a negative value of <code>iIndex</code>, the mainContent is inserted at position 0; for a value     
         *        greater than the current size of the aggregation, the mainContent is inserted at            
         * the last position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertMainContent(oMainContent: sap.ui.core.Control, iIndex: number): sap.ui.layout.DynamicSideContent;

        /**
         * Inserts a sideContent into the aggregation <code>sideContent</code>.
         * @param oSideContent the sideContent to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the sideContent should be inserted at; for            
         * a negative value of <code>iIndex</code>, the sideContent is inserted at position 0; for a value     
         *        greater than the current size of the aggregation, the sideContent is inserted at            
         * the last position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertSideContent(oSideContent: sap.ui.core.Control, iIndex: number): sap.ui.layout.DynamicSideContent;

        /**
         * Removes all the controls from the aggregation <code>mainContent</code>.Additionally, it unregisters
         * them from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllMainContent(): sap.ui.core.Control[];

        /**
         * Removes all the controls from the aggregation <code>sideContent</code>.Additionally, it unregisters
         * them from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllSideContent(): sap.ui.core.Control[];

        /**
         * Removes a mainContent from the aggregation <code>mainContent</code>.
         * @param vMainContent The mainContent to remove or its index or id
         * @returns The removed mainContent or <code>null</code>
        */
        removeMainContent(vMainContent: number | string | sap.ui.core.Control): sap.ui.core.Control;

        /**
         * Removes a sideContent from the aggregation <code>sideContent</code>.
         * @param vSideContent The sideContent to remove or its index or id
         * @returns The removed sideContent or <code>null</code>
        */
        removeSideContent(vSideContent: number | string | sap.ui.core.Control): sap.ui.core.Control;

        /**
         * Sets a new value for property <code>containerQuery</code>.If set to TRUE, then not the media Query
         * (device screen size) but the size of the container, surrounding the control, defines the current
         * range.When called with a value of <code>null</code> or <code>undefined</code>, the default value of
         * the property will be restored.Default value is <code>false</code>.
         * @param bContainerQuery New value for property <code>containerQuery</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setContainerQuery(bContainerQuery: boolean): sap.ui.layout.DynamicSideContent;

        /**
         * Sets or unsets the page in equalSplit mode.
         * @param bState Determines if the page is set to equalSplit mode
         * @returns this pointer for chaining
        */
        setEqualSplit(bState: boolean): any;

        /**
         * Sets the showMainContent property.
         * @param bVisible Determines if the main content part is visible
         * @param bSuppressVisualUpdate Determines if the visual state is updated
         * @returns this pointer for chaining
        */
        setShowMainContent(bVisible: boolean, bSuppressVisualUpdate: boolean): any;

        /**
         * Sets the showSideContent property.
         * @param bVisible Determines if the side content part is visible
         * @param bSuppressVisualUpdate Determines if the visual state is updated
         * @returns this pointer for chaining
        */
        setShowSideContent(bVisible: boolean, bSuppressVisualUpdate: boolean): any;

        /**
         * Sets a new value for property <code>sideContentFallDown</code>.Determines on which breakpoints the
         * side content falls down below the main content.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.Default value is
         * <code>OnMinimumWidth</code>.
         * @param sSideContentFallDown New value for property <code>sideContentFallDown</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setSideContentFallDown(sSideContentFallDown: sap.ui.layout.SideContentFallDown): sap.ui.layout.DynamicSideContent;

        /**
         * Sets a new value for property <code>sideContentPosition</code>.Determines whether the side content
         * is on the left or on the right side of the main content.When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>End</code>.
         * @since 1.36
         * @param sSideContentPosition New value for property <code>sideContentPosition</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setSideContentPosition(sSideContentPosition: sap.ui.layout.SideContentPosition): sap.ui.layout.DynamicSideContent;

        /**
         * Sets a new value for property <code>sideContentVisibility</code>.Determines on which breakpoints the
         * side content is visible.When called with a value of <code>null</code> or <code>undefined</code>, the
         * default value of the property will be restored.Default value is <code>ShowAboveS</code>.
         * @param sSideContentVisibility New value for property <code>sideContentVisibility</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setSideContentVisibility(sSideContentVisibility: sap.ui.layout.SideContentVisibility): sap.ui.layout.DynamicSideContent;

        /**
         * Used for the toggle button functionality.When the control is on a phone screen size only, one
         * control area is visible.This helper method is used to implement a button/switch for changingbetween
         * the main and side content areas.Only works if the current breakpoint is "S".
         * @returns this pointer for chaining
        */
        toggle(): any;
      }
      /**
       * ResponsiveSplitter is a control that enables responsiveness of normal Splitter.ResponsiveSplitter
       * consists of PaneContainers that further  agregate other PaneContainers and SplitPanes.SplitPanes can
       * be moved to the pagination when a minimum width of their parent is reached.
       * @resource sap/ui/layout/ResponsiveSplitter.js
      */
      export class ResponsiveSplitter extends sap.ui.core.Control {


        /**
         * Constructor for a new ResponsiveSplitter.Accepts an object literal <code>mSettings</code> that
         * defines initialproperty values, aggregated and associated objects as well as event handlers.See
         * {@link sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the
         * settings object.
         * @param sId ID for the new control, generated automatically if no ID is given
         * @param mSettings Initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Destroys the rootPaneContainer in the aggregation <code>rootPaneContainer</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyRootPaneContainer(): sap.ui.layout.ResponsiveSplitter;


        /**
         * ID of the element which is the current target of the association <code>defaultPane</code>, or
         * <code>null</code>.
        */
        getDefaultPane(): any;

        /**
         * Gets current value of property <code>height</code>.The height of the controlDefault value is
         * <code>100%</code>.
         * @returns Value of property <code>height</code>
        */
        getHeight(): any;

        /**
         * Returns a metadata object for class sap.ui.layout.ResponsiveSplitter.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets content of aggregation <code>rootPaneContainer</code>.The root PaneContainer of the
         * ResponsiveSplitter
        */
        getRootPaneContainer(): sap.ui.layout.PaneContainer;

        /**
         * Gets current value of property <code>width</code>.The width of the controlDefault value is
         * <code>100%</code>.
         * @returns Value of property <code>width</code>
        */
        getWidth(): any;

        /**
         * Sets the associated <code>defaultPane</code>.
         * @param oDefaultPane ID of an element which becomes the new target of this defaultPane association;
         * alternatively, an element instance may be given
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setDefaultPane(oDefaultPane: any | sap.ui.layout.SplitPane): sap.ui.layout.ResponsiveSplitter;

        /**
         * Sets a new value for property <code>height</code>.The height of the controlWhen called with a value
         * of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>100%</code>.
         * @param sHeight New value for property <code>height</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setHeight(sHeight: any): sap.ui.layout.ResponsiveSplitter;

        /**
         * Sets the aggregated <code>rootPaneContainer</code>.
         * @param oRootPaneContainer The rootPaneContainer to set
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setRootPaneContainer(oRootPaneContainer: sap.ui.layout.PaneContainer): sap.ui.layout.ResponsiveSplitter;

        /**
         * Sets a new value for property <code>width</code>.The width of the controlWhen called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>100%</code>.
         * @param sWidth New value for property <code>width</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setWidth(sWidth: any): sap.ui.layout.ResponsiveSplitter;
      }
      /**
       * Holds layout data for the splitter contents.Allowed size values are numeric values ending in "px"
       * and "%" and thespecial case "auto".(The CSS value "auto" is used internally to recalculate the size
       * of the contentdynamically and is not directly set as style property.)
       * @resource sap/ui/layout/SplitterLayoutData.js
      */
      export class SplitterLayoutData extends sap.ui.core.LayoutData {


        /**
         * Constructor for a new SplitterLayoutData.Accepts an object literal <code>mSettings</code> that
         * defines initialproperty values, aggregated and associated objects as well as event handlers.See
         * {@link sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the
         * settings object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);




        /**
         * Returns a metadata object for class sap.ui.layout.SplitterLayoutData.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>minSize</code>.Sets the minimum size of the splitter content in
         * px.Default value is <code>0</code>.
         * @returns Value of property <code>minSize</code>
        */
        getMinSize(): number;

        /**
         * Gets current value of property <code>resizable</code>.Determines whether the control in the splitter
         * can be resized or not.Default value is <code>true</code>.
         * @returns Value of property <code>resizable</code>
        */
        getResizable(): boolean;

        /**
         * Gets current value of property <code>size</code>.Sets the size of the splitter content.Default value
         * is <code>auto</code>.
         * @returns Value of property <code>size</code>
        */
        getSize(): any;

        /**
         * Sets a new value for property <code>minSize</code>.Sets the minimum size of the splitter content in
         * px.When called with a value of <code>null</code> or <code>undefined</code>, the default value of the
         * property will be restored.Default value is <code>0</code>.
         * @param iMinSize New value for property <code>minSize</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setMinSize(iMinSize: number): sap.ui.layout.SplitterLayoutData;

        /**
         * Sets a new value for property <code>resizable</code>.Determines whether the control in the splitter
         * can be resized or not.When called with a value of <code>null</code> or <code>undefined</code>, the
         * default value of the property will be restored.Default value is <code>true</code>.
         * @param bResizable New value for property <code>resizable</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setResizable(bResizable: boolean): sap.ui.layout.SplitterLayoutData;

        /**
         * Sets a new value for property <code>size</code>.Sets the size of the splitter content.When called
         * with a value of <code>null</code> or <code>undefined</code>, the default value of the property will
         * be restored.Default value is <code>auto</code>.
         * @param sSize New value for property <code>size</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setSize(sSize: any): sap.ui.layout.SplitterLayoutData;
      }
      /**
       * This is a layout where several controls can be added. These controls are blown up to fit in an
       * entire row. If the window resizes, the controls are moved between the rows and resized again.
       * @resource sap/ui/layout/ResponsiveFlowLayout.js
      */
      export class ResponsiveFlowLayout extends sap.ui.core.Control {


        /**
         * Constructor for a new ResponsiveFlowLayout.Accepts an object literal <code>mSettings</code> that
         * defines initialproperty values, aggregated and associated objects as well as event handlers.See
         * {@link sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the
         * settings object.
         * @param sId ID for the new control, generated automatically if no ID is given
         * @param mSettings Initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Adds content.This function needs to be overridden to prevent any rendering while somecontent is
         * still being added.
         * @param oContent The content that should be added to the layout
        */
        addContent(oContent: sap.ui.core.Control): void;

        /**
         * Destroys all the content in the aggregation <code>content</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyContent(): sap.ui.layout.ResponsiveFlowLayout;


        /**
         * Gets content of aggregation <code>content</code>.Added content that should be positioned. Every
         * content item should have a ResponsiveFlowLayoutData attached, or otherwise, the default values are
         * used.
        */
        getContent(): sap.ui.core.Control[];

        /**
         * Returns a metadata object for class sap.ui.layout.ResponsiveFlowLayout.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>responsive</code>.If set to false, all added controls will keep
         * their width, or otherwise, the controls will be stretched to the possible width of a row.Default
         * value is <code>true</code>.
         * @returns Value of property <code>responsive</code>
        */
        getResponsive(): boolean;

        /**
         * Checks for the provided <code>sap.ui.core.Control</code> in the aggregation <code>content</code>.and
         * returns its index if found or -1 otherwise.
         * @param oContent The content whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfContent(oContent: sap.ui.core.Control): number;

        /**
         * Inserts content.This function needs to be overridden to prevent any rendering while somecontent is
         * still being added.
         * @param oContent The content that should be inserted to the layout
         * @param iIndex The index where the content should be inserted into
        */
        insertContent(oContent: sap.ui.core.Control, iIndex: number): void;

        /**
         * Removes all the controls from the aggregation <code>content</code>.Additionally, it unregisters them
         * from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllContent(): sap.ui.core.Control[];

        /**
         * Removes content.This function needs to be overridden to prevent any rendering while somecontent is
         * still being added.
         * @param oContent The content that should be removed from the layout
         * @returns The <code>this</code> pointer for chaining
        */
        removeContent(oContent: number | string | sap.ui.core.Control): sap.ui.core.Control;

        /**
         * Sets a new value for property <code>responsive</code>.If set to false, all added controls will keep
         * their width, or otherwise, the controls will be stretched to the possible width of a row.When called
         * with a value of <code>null</code> or <code>undefined</code>, the default value of the property will
         * be restored.Default value is <code>true</code>.
         * @param bResponsive New value for property <code>responsive</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setResponsive(bResponsive: boolean): sap.ui.layout.ResponsiveFlowLayout;
      }
      /**
       * This is a LayoutData element that can be added to a control if this control is used within a
       * ResponsiveFlowLayout.
       * @resource sap/ui/layout/ResponsiveFlowLayoutData.js
      */
      export class ResponsiveFlowLayoutData extends sap.ui.core.LayoutData {


        /**
         * Constructor for a new ResponsiveFlowLayoutData.Accepts an object literal <code>mSettings</code> that
         * defines initialproperty values, aggregated and associated objects as well as event handlers.See
         * {@link sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the
         * settings object.
         * @param sId ID for the new control, generated automatically if no ID is given
         * @param mSettings Initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);




        /**
         * Gets current value of property <code>linebreak</code>.If this property is set, the control in which
         * the LayoutData is added, will always cause a line break within the ResponsiveFlowLayout.Default
         * value is <code>false</code>.
         * @returns Value of property <code>linebreak</code>
        */
        getLinebreak(): boolean;

        /**
         * Gets current value of property <code>linebreakable</code>.Shows if an element can be wrapped into a
         * new row. If this value is set to false, the min-width will be set to 0 and the wrapping is up to the
         * previous element.Default value is <code>true</code>.
         * @returns Value of property <code>linebreakable</code>
        */
        getLinebreakable(): boolean;

        /**
         * Gets current value of property <code>margin</code>.Prevents any margin of the element if set to
         * false.Default value is <code>true</code>.
         * @returns Value of property <code>margin</code>
        */
        getMargin(): boolean;

        /**
         * Returns a metadata object for class sap.ui.layout.ResponsiveFlowLayoutData.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>minWidth</code>.Defines the minimal size in px of an
         * ResponsiveFlowLayout element. The element will be shrunk down to this value.Default value is
         * <code>100</code>.
         * @returns Value of property <code>minWidth</code>
        */
        getMinWidth(): number;

        /**
         * Gets current value of property <code>weight</code>.Defines the weight of the element, that
         * influences the resulting width. If there are several elements within a row of the
         * ResponsiveFlowLayout, each element could have another weight. The bigger the weight of a single
         * element, the wider it will be stretched, i.e. a bigger weight results in a larger width.Default
         * value is <code>1</code>.
         * @returns Value of property <code>weight</code>
        */
        getWeight(): number;

        /**
         * Sets a new value for property <code>linebreak</code>.If this property is set, the control in which
         * the LayoutData is added, will always cause a line break within the ResponsiveFlowLayout.When called
         * with a value of <code>null</code> or <code>undefined</code>, the default value of the property will
         * be restored.Default value is <code>false</code>.
         * @param bLinebreak New value for property <code>linebreak</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setLinebreak(bLinebreak: boolean): sap.ui.layout.ResponsiveFlowLayoutData;

        /**
         * Sets a new value for property <code>linebreakable</code>.Shows if an element can be wrapped into a
         * new row. If this value is set to false, the min-width will be set to 0 and the wrapping is up to the
         * previous element.When called with a value of <code>null</code> or <code>undefined</code>, the
         * default value of the property will be restored.Default value is <code>true</code>.
         * @param bLinebreakable New value for property <code>linebreakable</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setLinebreakable(bLinebreakable: boolean): sap.ui.layout.ResponsiveFlowLayoutData;

        /**
         * Sets a new value for property <code>margin</code>.Prevents any margin of the element if set to
         * false.When called with a value of <code>null</code> or <code>undefined</code>, the default value of
         * the property will be restored.Default value is <code>true</code>.
         * @param bMargin New value for property <code>margin</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setMargin(bMargin: boolean): sap.ui.layout.ResponsiveFlowLayoutData;

        /**
         * Sets a new value for property <code>minWidth</code>.Defines the minimal size in px of an
         * ResponsiveFlowLayout element. The element will be shrunk down to this value.When called with a value
         * of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>100</code>.
         * @param iMinWidth New value for property <code>minWidth</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setMinWidth(iMinWidth: number): sap.ui.layout.ResponsiveFlowLayoutData;

        /**
         * Sets a new value for property <code>weight</code>.Defines the weight of the element, that influences
         * the resulting width. If there are several elements within a row of the ResponsiveFlowLayout, each
         * element could have another weight. The bigger the weight of a single element, the wider it will be
         * stretched, i.e. a bigger weight results in a larger width.When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>1</code>.
         * @param iWeight New value for property <code>weight</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setWeight(iWeight: number): sap.ui.layout.ResponsiveFlowLayoutData;
      }
      /**
       * The position of the Grid. Can be "Left", "Center" or "Right". "Left" is default.
      */
      enum GridPosition {
        "Center",
        "Left",
        "Right"
      }
      /**
       * Available Background Design.
      */
      enum BackgroundDesign {
        "Solid",
        "Translucent",
        "Transparent"
      }
      /**
       * Types of the DynamicSideContent FallDown options
      */
      enum SideContentFallDown {
        "BelowL",
        "BelowM",
        "BelowXL",
        "OnMinimumWidth"
      }
      /**
       * The position of the side content - End (default) and Begin.
      */
      enum SideContentPosition {
        "Begin",
        "End"
      }
      /**
       * Types of the DynamicSideContent Visibility options
      */
      enum SideContentVisibility {
        "AlwaysShow",
        "NeverShow",
        "ShowAboveL",
        "ShowAboveM",
        "ShowAboveS"
      }
    }
    namespace unified {
      namespace calendar {
        /**
         * renders a month with ItemNavigationThis is used inside the calendar. Not for stand alone usageIf
         * used inside the calendar the properties and aggregation are directly taken from the parent(To not
         * duplicate and sync DateRanges and so on...)
         * @resource sap/ui/unified/calendar/Month.js
        */
        export class Month extends sap.ui.core.Control {


          /**
           * Constructor for a new calendar/Month.Accepts an object literal <code>mSettings</code> that defines
           * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
           * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
           * object.
           * @param sId id for the new control, generated automatically if no id is given
           * @param mSettings initial settings for the new control
          */
          constructor(sId: string, mSettings?: any);



          /**
           * Adds some ariaLabelledBy into the association <code>ariaLabelledBy</code>.
           * @param vAriaLabelledBy the ariaLabelledBy to add; if empty, nothing is inserted
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          addAriaLabelledBy(vAriaLabelledBy: any | sap.ui.core.Control): sap.ui.unified.calendar.Month;

          /**
           * Adds some disabledDate to the aggregation <code>disabledDates</code>.
           * @since 1.38.0
           * @param oDisabledDate the disabledDate to add; if empty, nothing is inserted
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          addDisabledDate(oDisabledDate: sap.ui.unified.DateRange): sap.ui.unified.calendar.Month;

          /**
           * Adds some selectedDate to the aggregation <code>selectedDates</code>.
           * @param oSelectedDate the selectedDate to add; if empty, nothing is inserted
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          addSelectedDate(oSelectedDate: sap.ui.unified.DateRange): sap.ui.unified.calendar.Month;

          /**
           * Adds some specialDate to the aggregation <code>specialDates</code>.
           * @param oSpecialDate the specialDate to add; if empty, nothing is inserted
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          addSpecialDate(oSpecialDate: sap.ui.unified.DateTypeRange): sap.ui.unified.calendar.Month;

          /**
           * Attaches event handler <code>fnFunction</code> to the <code>focus</code> event of this
           * <code>sap.ui.unified.calendar.Month</code>.When called, the context of the event handler (its
           * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
           * to this <code>sap.ui.unified.calendar.Month</code> itself.Date focus changed
           * @param oData An application-specific payload object that will be passed to the event handler along
           * with the event object when firing the event
           * @param fnFunction The function to be called when the event occurs
           * @param oListener Context object to call the event handler with. Defaults to this
           * <code>sap.ui.unified.calendar.Month</code> itself
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          attachFocus(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.calendar.Month;

          /**
           * Attaches event handler <code>fnFunction</code> to the <code>select</code> event of this
           * <code>sap.ui.unified.calendar.Month</code>.When called, the context of the event handler (its
           * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
           * to this <code>sap.ui.unified.calendar.Month</code> itself.Date selection changed
           * @param oData An application-specific payload object that will be passed to the event handler along
           * with the event object when firing the event
           * @param fnFunction The function to be called when the event occurs
           * @param oListener Context object to call the event handler with. Defaults to this
           * <code>sap.ui.unified.calendar.Month</code> itself
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          attachSelect(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.calendar.Month;

          /**
           * checks if a date is focusable in the current rendered output.So if not rendered or in other month it
           * is not focusable.
           * @param oDate JavaScript date object for focused date.
           * @returns flag if focusable
          */
          checkDateFocusable(oDate: any): boolean;

          /**
           * Destroys all the disabledDates in the aggregation <code>disabledDates</code>.
           * @since 1.38.0
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          destroyDisabledDates(): sap.ui.unified.calendar.Month;

          /**
           * Destroys all the selectedDates in the aggregation <code>selectedDates</code>.
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          destroySelectedDates(): sap.ui.unified.calendar.Month;

          /**
           * Destroys all the specialDates in the aggregation <code>specialDates</code>.
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          destroySpecialDates(): sap.ui.unified.calendar.Month;

          /**
           * Detaches event handler <code>fnFunction</code> from the <code>focus</code> event of this
           * <code>sap.ui.unified.calendar.Month</code>.The passed function and listener object must match the
           * ones used for event registration.
           * @param fnFunction The function to be called, when the event occurs
           * @param oListener Context object on which the given function had to be called
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          detachFocus(fnFunction: any, oListener: any): sap.ui.unified.calendar.Month;

          /**
           * Detaches event handler <code>fnFunction</code> from the <code>select</code> event of this
           * <code>sap.ui.unified.calendar.Month</code>.The passed function and listener object must match the
           * ones used for event registration.
           * @param fnFunction The function to be called, when the event occurs
           * @param oListener Context object on which the given function had to be called
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          detachSelect(fnFunction: any, oListener: any): sap.ui.unified.calendar.Month;

          /**
           * displays the month of a given date without setting the focus
           * @param oDate JavaScript date object for focused date.
           * @returns <code>this</code> to allow method chaining
          */
          displayDate(oDate: any): sap.ui.unified.calendar.Month;


          /**
           * Fires event <code>focus</code> to attached listeners.Expects the following event
           * parameters:<ul><li><code>date</code> of type <code>object</code>focused
           * date</li><li><code>otherMonth</code> of type <code>boolean</code>focused date is in an other month
           * that the displayed one</li><li><code>restoreOldDate</code> of type <code>boolean</code>focused date
           * is set to the same as before (date in other month clicked)</li></ul>
           * @param mArguments The arguments to pass along with the event
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          fireFocus(mArguments: any): sap.ui.unified.calendar.Month;

          /**
           * Fires event <code>select</code> to attached listeners.
           * @param mArguments The arguments to pass along with the event
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          fireSelect(mArguments: any): sap.ui.unified.calendar.Month;

          /**
           * Returns array of IDs of the elements which are the current targets of the association
           * <code>ariaLabelledBy</code>.
          */
          getAriaLabelledBy(): any[];

          /**
           * Gets current value of property <code>date</code>.the month including this date is rendered and this
           * date is initial focused (if no other focus set)
           * @returns Value of property <code>date</code>
          */
          getDate(): any;

          /**
           * Gets content of aggregation <code>disabledDates</code>.Date Ranges for disabled dates
           * @since 1.38.0
          */
          getDisabledDates(): sap.ui.unified.DateRange[];

          /**
           * Gets current value of property <code>firstDayOfWeek</code>.If set, the first day of the displayed
           * week is this day. Valid values are 0 to 6.If not a valid value is set, the default of the used
           * locale is used.Default value is <code>-1</code>.
           * @since 1.28.9
           * @returns Value of property <code>firstDayOfWeek</code>
          */
          getFirstDayOfWeek(): number;

          /**
           * Gets current value of property <code>intervalSelection</code>.If set, interval selection is
           * allowedDefault value is <code>false</code>.
           * @returns Value of property <code>intervalSelection</code>
          */
          getIntervalSelection(): boolean;

          /**
           * ID of the element which is the current target of the association <code>legend</code>, or
           * <code>null</code>.
           * @since 1.38.5
          */
          getLegend(): any;

          /**
           * Returns a metadata object for class sap.ui.unified.calendar.Month.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Gets current value of property <code>nonWorkingDays</code>.If set, the provided weekdays are
           * displayed as non-working days.Valid values inside the array are 0 to 6.If not set, the weekend
           * defined in the locale settings is displayed as non-working days.
           * @since 1.28.9
           * @returns Value of property <code>nonWorkingDays</code>
          */
          getNonWorkingDays(): number;

          /**
           * Gets current value of property <code>primaryCalendarType</code>.If set, the calendar type is used
           * for display.If not set, the calendar type of the global configuration is used.
           * @since 1.34.0
           * @returns Value of property <code>primaryCalendarType</code>
          */
          getPrimaryCalendarType(): sap.ui.core.CalendarType;

          /**
           * Gets current value of property <code>secondaryCalendarType</code>.If set, the days are also
           * displayed in this calendar typeIf not set, the dates are only displayed in the primary calendar type
           * @since 1.34.0
           * @returns Value of property <code>secondaryCalendarType</code>
          */
          getSecondaryCalendarType(): sap.ui.core.CalendarType;

          /**
           * Gets content of aggregation <code>selectedDates</code>.Date Ranges for selected dates of the
           * DatePicker
          */
          getSelectedDates(): sap.ui.unified.DateRange[];

          /**
           * Gets current value of property <code>showHeader</code>.If set, a header with the month name is
           * shownDefault value is <code>false</code>.
           * @returns Value of property <code>showHeader</code>
          */
          getShowHeader(): boolean;

          /**
           * Gets current value of property <code>singleSelection</code>.If set, only a single date or interval,
           * if intervalSelection is enabled, can be selectedDefault value is <code>true</code>.
           * @returns Value of property <code>singleSelection</code>
          */
          getSingleSelection(): boolean;

          /**
           * Gets content of aggregation <code>specialDates</code>.Date Range with type to visualize special days
           * in the Calendar.If one day is assigned to more than one Type, only the first one will be used.
          */
          getSpecialDates(): sap.ui.unified.DateTypeRange[];

          /**
           * Gets current value of property <code>width</code>.Width of Month
           * @since 1.38.0
           * @returns Value of property <code>width</code>
          */
          getWidth(): any;

          /**
           * Checks for the provided <code>sap.ui.unified.DateRange</code> in the aggregation
           * <code>disabledDates</code>.and returns its index if found or -1 otherwise.
           * @since 1.38.0
           * @param oDisabledDate The disabledDate whose index is looked for
           * @returns The index of the provided control in the aggregation if found, or -1 otherwise
          */
          indexOfDisabledDate(oDisabledDate: sap.ui.unified.DateRange): number;

          /**
           * Checks for the provided <code>sap.ui.unified.DateRange</code> in the aggregation
           * <code>selectedDates</code>.and returns its index if found or -1 otherwise.
           * @param oSelectedDate The selectedDate whose index is looked for
           * @returns The index of the provided control in the aggregation if found, or -1 otherwise
          */
          indexOfSelectedDate(oSelectedDate: sap.ui.unified.DateRange): number;

          /**
           * Checks for the provided <code>sap.ui.unified.DateTypeRange</code> in the aggregation
           * <code>specialDates</code>.and returns its index if found or -1 otherwise.
           * @param oSpecialDate The specialDate whose index is looked for
           * @returns The index of the provided control in the aggregation if found, or -1 otherwise
          */
          indexOfSpecialDate(oSpecialDate: sap.ui.unified.DateTypeRange): number;

          /**
           * Inserts a disabledDate into the aggregation <code>disabledDates</code>.
           * @since 1.38.0
           * @param oDisabledDate the disabledDate to insert; if empty, nothing is inserted
           * @param iIndex the <code>0</code>-based index the disabledDate should be inserted at; for            
           * a negative value of <code>iIndex</code>, the disabledDate is inserted at position 0; for a value    
           *         greater than the current size of the aggregation, the disabledDate is inserted at           
           *  the last position
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          insertDisabledDate(oDisabledDate: sap.ui.unified.DateRange, iIndex: number): sap.ui.unified.calendar.Month;

          /**
           * Inserts a selectedDate into the aggregation <code>selectedDates</code>.
           * @param oSelectedDate the selectedDate to insert; if empty, nothing is inserted
           * @param iIndex the <code>0</code>-based index the selectedDate should be inserted at; for            
           * a negative value of <code>iIndex</code>, the selectedDate is inserted at position 0; for a value    
           *         greater than the current size of the aggregation, the selectedDate is inserted at           
           *  the last position
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          insertSelectedDate(oSelectedDate: sap.ui.unified.DateRange, iIndex: number): sap.ui.unified.calendar.Month;

          /**
           * Inserts a specialDate into the aggregation <code>specialDates</code>.
           * @param oSpecialDate the specialDate to insert; if empty, nothing is inserted
           * @param iIndex the <code>0</code>-based index the specialDate should be inserted at; for            
           * a negative value of <code>iIndex</code>, the specialDate is inserted at position 0; for a value     
           *        greater than the current size of the aggregation, the specialDate is inserted at            
           * the last position
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          insertSpecialDate(oSpecialDate: sap.ui.unified.DateTypeRange, iIndex: number): sap.ui.unified.calendar.Month;

          /**
           * Removes all the controls in the association named <code>ariaLabelledBy</code>.
           * @returns An array of the removed elements (might be empty)
          */
          removeAllAriaLabelledBy(): any[];

          /**
           * Removes all the controls from the aggregation <code>disabledDates</code>.Additionally, it
           * unregisters them from the hosting UIArea.
           * @since 1.38.0
           * @returns An array of the removed elements (might be empty)
          */
          removeAllDisabledDates(): sap.ui.unified.DateRange[];

          /**
           * Removes all the controls from the aggregation <code>selectedDates</code>.Additionally, it
           * unregisters them from the hosting UIArea.
           * @returns An array of the removed elements (might be empty)
          */
          removeAllSelectedDates(): sap.ui.unified.DateRange[];

          /**
           * Removes all the controls from the aggregation <code>specialDates</code>.Additionally, it unregisters
           * them from the hosting UIArea.
           * @returns An array of the removed elements (might be empty)
          */
          removeAllSpecialDates(): sap.ui.unified.DateTypeRange[];

          /**
           * Removes an ariaLabelledBy from the association named <code>ariaLabelledBy</code>.
           * @param vAriaLabelledBy The ariaLabelledBy to be removed or its index or ID
           * @returns The removed ariaLabelledBy or <code>null</code>
          */
          removeAriaLabelledBy(vAriaLabelledBy: number | any | sap.ui.core.Control): any;

          /**
           * Removes a disabledDate from the aggregation <code>disabledDates</code>.
           * @since 1.38.0
           * @param vDisabledDate The disabledDate to remove or its index or id
           * @returns The removed disabledDate or <code>null</code>
          */
          removeDisabledDate(vDisabledDate: number | string | sap.ui.unified.DateRange): sap.ui.unified.DateRange;

          /**
           * Removes a selectedDate from the aggregation <code>selectedDates</code>.
           * @param vSelectedDate The selectedDate to remove or its index or id
           * @returns The removed selectedDate or <code>null</code>
          */
          removeSelectedDate(vSelectedDate: number | string | sap.ui.unified.DateRange): sap.ui.unified.DateRange;

          /**
           * Removes a specialDate from the aggregation <code>specialDates</code>.
           * @param vSpecialDate The specialDate to remove or its index or id
           * @returns The removed specialDate or <code>null</code>
          */
          removeSpecialDate(vSpecialDate: number | string | sap.ui.unified.DateTypeRange): sap.ui.unified.DateTypeRange;

          /**
           * Sets a new value for property <code>date</code>.the month including this date is rendered and this
           * date is initial focused (if no other focus set)When called with a value of <code>null</code> or
           * <code>undefined</code>, the default value of the property will be restored.
           * @param oDate New value for property <code>date</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setDate(oDate: any): sap.ui.unified.calendar.Month;

          /**
           * Sets a new value for property <code>firstDayOfWeek</code>.If set, the first day of the displayed
           * week is this day. Valid values are 0 to 6.If not a valid value is set, the default of the used
           * locale is used.When called with a value of <code>null</code> or <code>undefined</code>, the default
           * value of the property will be restored.Default value is <code>-1</code>.
           * @since 1.28.9
           * @param iFirstDayOfWeek New value for property <code>firstDayOfWeek</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setFirstDayOfWeek(iFirstDayOfWeek: number): void;

          /**
           * Sets a new value for property <code>intervalSelection</code>.If set, interval selection is
           * allowedWhen called with a value of <code>null</code> or <code>undefined</code>, the default value of
           * the property will be restored.Default value is <code>false</code>.
           * @param bIntervalSelection New value for property <code>intervalSelection</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setIntervalSelection(bIntervalSelection: boolean): sap.ui.unified.calendar.Month;

          /**
           * Sets the associated <code>legend</code>.
           * @since 1.38.5
           * @param oLegend ID of an element which becomes the new target of this legend association;
           * alternatively, an element instance may be given
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setLegend(oLegend: any | sap.ui.unified.CalendarLegend): sap.ui.unified.calendar.Month;

          /**
           * Sets a new value for property <code>nonWorkingDays</code>.If set, the provided weekdays are
           * displayed as non-working days.Valid values inside the array are 0 to 6.If not set, the weekend
           * defined in the locale settings is displayed as non-working days.When called with a value of
           * <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
           * @since 1.28.9
           * @param sNonWorkingDays New value for property <code>nonWorkingDays</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setNonWorkingDays(sNonWorkingDays: number): sap.ui.unified.calendar.Month;

          /**
           * Sets a new value for property <code>primaryCalendarType</code>.If set, the calendar type is used for
           * display.If not set, the calendar type of the global configuration is used.When called with a value
           * of <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
           * @since 1.34.0
           * @param sPrimaryCalendarType New value for property <code>primaryCalendarType</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setPrimaryCalendarType(sPrimaryCalendarType: sap.ui.core.CalendarType): sap.ui.unified.calendar.Month;

          /**
           * Sets a new value for property <code>secondaryCalendarType</code>.If set, the days are also displayed
           * in this calendar typeIf not set, the dates are only displayed in the primary calendar typeWhen
           * called with a value of <code>null</code> or <code>undefined</code>, the default value of the
           * property will be restored.
           * @since 1.34.0
           * @param sSecondaryCalendarType New value for property <code>secondaryCalendarType</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setSecondaryCalendarType(sSecondaryCalendarType: sap.ui.core.CalendarType): sap.ui.unified.calendar.Month;

          /**
           * Sets a new value for property <code>showHeader</code>.If set, a header with the month name is
           * shownWhen called with a value of <code>null</code> or <code>undefined</code>, the default value of
           * the property will be restored.Default value is <code>false</code>.
           * @param bShowHeader New value for property <code>showHeader</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setShowHeader(bShowHeader: boolean): sap.ui.unified.calendar.Month;

          /**
           * Sets a new value for property <code>singleSelection</code>.If set, only a single date or interval,
           * if intervalSelection is enabled, can be selectedWhen called with a value of <code>null</code> or
           * <code>undefined</code>, the default value of the property will be restored.Default value is
           * <code>true</code>.
           * @param bSingleSelection New value for property <code>singleSelection</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setSingleSelection(bSingleSelection: boolean): sap.ui.unified.calendar.Month;

          /**
           * Sets a new value for property <code>width</code>.Width of MonthWhen called with a value of
           * <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
           * @since 1.38.0
           * @param sWidth New value for property <code>width</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setWidth(sWidth: any): sap.ui.unified.calendar.Month;
        }
        /**
         * renders a calendar headerThe calendar header consists of 3 buttons where the text can be set and a
         * previous and a next button.In the normal calendar the first button contains the displayed day, the
         * second button the displayed month and the third button the displayed year.<b>Note:</b> This is used
         * inside the calendar. Not for standalone usage
         * @resource sap/ui/unified/calendar/Header.js
        */
        export class Header extends sap.ui.core.Control {


          /**
           * Constructor for a new Header.Accepts an object literal <code>mSettings</code> that defines
           * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
           * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
           * object.
           * @param sId ID for the new control, generated automatically if no ID is given
           * @param mSettings Initial settings for the new control
          */
          constructor(sId: string, mSettings?: any);



          /**
           * Attaches event handler <code>fnFunction</code> to the <code>pressButton0</code> event of this
           * <code>sap.ui.unified.calendar.Header</code>.When called, the context of the event handler (its
           * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
           * to this <code>sap.ui.unified.calendar.Header</code> itself.First button pressed (normally day)
           * @since 1.32.0
           * @param oData An application-specific payload object that will be passed to the event handler along
           * with the event object when firing the event
           * @param fnFunction The function to be called when the event occurs
           * @param oListener Context object to call the event handler with. Defaults to this
           * <code>sap.ui.unified.calendar.Header</code> itself
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          attachPressButton0(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.calendar.Header;

          /**
           * Attaches event handler <code>fnFunction</code> to the <code>pressButton1</code> event of this
           * <code>sap.ui.unified.calendar.Header</code>.When called, the context of the event handler (its
           * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
           * to this <code>sap.ui.unified.calendar.Header</code> itself.Second button pressed (normally month)
           * @param oData An application-specific payload object that will be passed to the event handler along
           * with the event object when firing the event
           * @param fnFunction The function to be called when the event occurs
           * @param oListener Context object to call the event handler with. Defaults to this
           * <code>sap.ui.unified.calendar.Header</code> itself
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          attachPressButton1(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.calendar.Header;

          /**
           * Attaches event handler <code>fnFunction</code> to the <code>pressButton2</code> event of this
           * <code>sap.ui.unified.calendar.Header</code>.When called, the context of the event handler (its
           * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
           * to this <code>sap.ui.unified.calendar.Header</code> itself.Third button pressed (normally year)
           * @param oData An application-specific payload object that will be passed to the event handler along
           * with the event object when firing the event
           * @param fnFunction The function to be called when the event occurs
           * @param oListener Context object to call the event handler with. Defaults to this
           * <code>sap.ui.unified.calendar.Header</code> itself
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          attachPressButton2(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.calendar.Header;

          /**
           * Attaches event handler <code>fnFunction</code> to the <code>pressNext</code> event of this
           * <code>sap.ui.unified.calendar.Header</code>.When called, the context of the event handler (its
           * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
           * to this <code>sap.ui.unified.calendar.Header</code> itself.Next button pressed
           * @param oData An application-specific payload object that will be passed to the event handler along
           * with the event object when firing the event
           * @param fnFunction The function to be called when the event occurs
           * @param oListener Context object to call the event handler with. Defaults to this
           * <code>sap.ui.unified.calendar.Header</code> itself
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          attachPressNext(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.calendar.Header;

          /**
           * Attaches event handler <code>fnFunction</code> to the <code>pressPrevious</code> event of this
           * <code>sap.ui.unified.calendar.Header</code>.When called, the context of the event handler (its
           * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
           * to this <code>sap.ui.unified.calendar.Header</code> itself.Previous button pressed
           * @param oData An application-specific payload object that will be passed to the event handler along
           * with the event object when firing the event
           * @param fnFunction The function to be called when the event occurs
           * @param oListener Context object to call the event handler with. Defaults to this
           * <code>sap.ui.unified.calendar.Header</code> itself
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          attachPressPrevious(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.calendar.Header;

          /**
           * Detaches event handler <code>fnFunction</code> from the <code>pressButton0</code> event of this
           * <code>sap.ui.unified.calendar.Header</code>.The passed function and listener object must match the
           * ones used for event registration.
           * @since 1.32.0
           * @param fnFunction The function to be called, when the event occurs
           * @param oListener Context object on which the given function had to be called
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          detachPressButton0(fnFunction: any, oListener: any): sap.ui.unified.calendar.Header;

          /**
           * Detaches event handler <code>fnFunction</code> from the <code>pressButton1</code> event of this
           * <code>sap.ui.unified.calendar.Header</code>.The passed function and listener object must match the
           * ones used for event registration.
           * @param fnFunction The function to be called, when the event occurs
           * @param oListener Context object on which the given function had to be called
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          detachPressButton1(fnFunction: any, oListener: any): sap.ui.unified.calendar.Header;

          /**
           * Detaches event handler <code>fnFunction</code> from the <code>pressButton2</code> event of this
           * <code>sap.ui.unified.calendar.Header</code>.The passed function and listener object must match the
           * ones used for event registration.
           * @param fnFunction The function to be called, when the event occurs
           * @param oListener Context object on which the given function had to be called
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          detachPressButton2(fnFunction: any, oListener: any): sap.ui.unified.calendar.Header;

          /**
           * Detaches event handler <code>fnFunction</code> from the <code>pressNext</code> event of this
           * <code>sap.ui.unified.calendar.Header</code>.The passed function and listener object must match the
           * ones used for event registration.
           * @param fnFunction The function to be called, when the event occurs
           * @param oListener Context object on which the given function had to be called
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          detachPressNext(fnFunction: any, oListener: any): sap.ui.unified.calendar.Header;

          /**
           * Detaches event handler <code>fnFunction</code> from the <code>pressPrevious</code> event of this
           * <code>sap.ui.unified.calendar.Header</code>.The passed function and listener object must match the
           * ones used for event registration.
           * @param fnFunction The function to be called, when the event occurs
           * @param oListener Context object on which the given function had to be called
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          detachPressPrevious(fnFunction: any, oListener: any): sap.ui.unified.calendar.Header;


          /**
           * Fires event <code>pressButton0</code> to attached listeners.
           * @since 1.32.0
           * @param mArguments The arguments to pass along with the event
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          firePressButton0(mArguments: any): sap.ui.unified.calendar.Header;

          /**
           * Fires event <code>pressButton1</code> to attached listeners.
           * @param mArguments The arguments to pass along with the event
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          firePressButton1(mArguments: any): sap.ui.unified.calendar.Header;

          /**
           * Fires event <code>pressButton2</code> to attached listeners.
           * @param mArguments The arguments to pass along with the event
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          firePressButton2(mArguments: any): sap.ui.unified.calendar.Header;

          /**
           * Fires event <code>pressNext</code> to attached listeners.
           * @param mArguments The arguments to pass along with the event
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          firePressNext(mArguments: any): sap.ui.unified.calendar.Header;

          /**
           * Fires event <code>pressPrevious</code> to attached listeners.
           * @param mArguments The arguments to pass along with the event
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          firePressPrevious(mArguments: any): sap.ui.unified.calendar.Header;

          /**
           * Gets current value of property <code>additionalTextButton0</code>.Additional text of the first
           * button (normally day)
           * @since 1.34.0
           * @returns Value of property <code>additionalTextButton0</code>
          */
          getAdditionalTextButton0(): string;

          /**
           * Gets current value of property <code>additionalTextButton1</code>.Additional text of the second
           * button (normally month)
           * @since 1.34.0
           * @returns Value of property <code>additionalTextButton1</code>
          */
          getAdditionalTextButton1(): string;

          /**
           * Gets current value of property <code>additionalTextButton2</code>.Additional text of the third
           * button (normally year)
           * @since 1.34.0
           * @returns Value of property <code>additionalTextButton2</code>
          */
          getAdditionalTextButton2(): string;

          /**
           * Gets current value of property <code>ariaLabelButton0</code>.aria-label of the first button
           * (normally day)
           * @since 1.32.0
           * @returns Value of property <code>ariaLabelButton0</code>
          */
          getAriaLabelButton0(): string;

          /**
           * Gets current value of property <code>ariaLabelButton1</code>.aria-label of the second button
           * (normally month)
           * @returns Value of property <code>ariaLabelButton1</code>
          */
          getAriaLabelButton1(): string;

          /**
           * Gets current value of property <code>ariaLabelButton2</code>.aria-label of the third button
           * (normally year)
           * @returns Value of property <code>ariaLabelButton2</code>
          */
          getAriaLabelButton2(): string;

          /**
           * Gets current value of property <code>enabledNext</code>.Enables the Next buttonDefault value is
           * <code>true</code>.
           * @returns Value of property <code>enabledNext</code>
          */
          getEnabledNext(): boolean;

          /**
           * Gets current value of property <code>enabledPrevious</code>.Enables the previous buttonDefault value
           * is <code>true</code>.
           * @returns Value of property <code>enabledPrevious</code>
          */
          getEnabledPrevious(): boolean;

          /**
           * Returns a metadata object for class sap.ui.unified.calendar.Header.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Gets current value of property <code>textButton0</code>.Text of the first button (normally day)
           * @since 1.32.0
           * @returns Value of property <code>textButton0</code>
          */
          getTextButton0(): string;

          /**
           * Gets current value of property <code>textButton1</code>.Text of the second button (normally month)
           * @returns Value of property <code>textButton1</code>
          */
          getTextButton1(): string;

          /**
           * Gets current value of property <code>textButton2</code>.Text of the third button (normally year)
           * @returns Value of property <code>textButton2</code>
          */
          getTextButton2(): string;

          /**
           * Gets current value of property <code>visibleButton0</code>.If set, the first button will be
           * displayed<b>Note:</b> The default is set to false to be compatible to older versionsDefault value is
           * <code>false</code>.
           * @since 1.32.0
           * @returns Value of property <code>visibleButton0</code>
          */
          getVisibleButton0(): boolean;

          /**
           * Gets current value of property <code>visibleButton1</code>.If set, the second button will be
           * displayedDefault value is <code>true</code>.
           * @since 1.32.0
           * @returns Value of property <code>visibleButton1</code>
          */
          getVisibleButton1(): boolean;

          /**
           * Gets current value of property <code>visibleButton2</code>.If set, the third button will be
           * displayedDefault value is <code>true</code>.
           * @since 1.32.0
           * @returns Value of property <code>visibleButton2</code>
          */
          getVisibleButton2(): boolean;

          /**
           * Sets a new value for property <code>additionalTextButton0</code>.Additional text of the first button
           * (normally day)When called with a value of <code>null</code> or <code>undefined</code>, the default
           * value of the property will be restored.
           * @since 1.34.0
           * @param sAdditionalTextButton0 New value for property <code>additionalTextButton0</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setAdditionalTextButton0(sAdditionalTextButton0: string): sap.ui.unified.calendar.Header;

          /**
           * Sets a new value for property <code>additionalTextButton1</code>.Additional text of the second
           * button (normally month)When called with a value of <code>null</code> or <code>undefined</code>, the
           * default value of the property will be restored.
           * @since 1.34.0
           * @param sAdditionalTextButton1 New value for property <code>additionalTextButton1</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setAdditionalTextButton1(sAdditionalTextButton1: string): sap.ui.unified.calendar.Header;

          /**
           * Sets a new value for property <code>additionalTextButton2</code>.Additional text of the third button
           * (normally year)When called with a value of <code>null</code> or <code>undefined</code>, the default
           * value of the property will be restored.
           * @since 1.34.0
           * @param sAdditionalTextButton2 New value for property <code>additionalTextButton2</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setAdditionalTextButton2(sAdditionalTextButton2: string): sap.ui.unified.calendar.Header;

          /**
           * Sets a new value for property <code>ariaLabelButton0</code>.aria-label of the first button (normally
           * day)When called with a value of <code>null</code> or <code>undefined</code>, the default value of
           * the property will be restored.
           * @since 1.32.0
           * @param sAriaLabelButton0 New value for property <code>ariaLabelButton0</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setAriaLabelButton0(sAriaLabelButton0: string): sap.ui.unified.calendar.Header;

          /**
           * Sets a new value for property <code>ariaLabelButton1</code>.aria-label of the second button
           * (normally month)When called with a value of <code>null</code> or <code>undefined</code>, the default
           * value of the property will be restored.
           * @param sAriaLabelButton1 New value for property <code>ariaLabelButton1</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setAriaLabelButton1(sAriaLabelButton1: string): sap.ui.unified.calendar.Header;

          /**
           * Sets a new value for property <code>ariaLabelButton2</code>.aria-label of the third button (normally
           * year)When called with a value of <code>null</code> or <code>undefined</code>, the default value of
           * the property will be restored.
           * @param sAriaLabelButton2 New value for property <code>ariaLabelButton2</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setAriaLabelButton2(sAriaLabelButton2: string): sap.ui.unified.calendar.Header;

          /**
           * Sets a new value for property <code>enabledNext</code>.Enables the Next buttonWhen called with a
           * value of <code>null</code> or <code>undefined</code>, the default value of the property will be
           * restored.Default value is <code>true</code>.
           * @param bEnabledNext New value for property <code>enabledNext</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setEnabledNext(bEnabledNext: boolean): sap.ui.unified.calendar.Header;

          /**
           * Sets a new value for property <code>enabledPrevious</code>.Enables the previous buttonWhen called
           * with a value of <code>null</code> or <code>undefined</code>, the default value of the property will
           * be restored.Default value is <code>true</code>.
           * @param bEnabledPrevious New value for property <code>enabledPrevious</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setEnabledPrevious(bEnabledPrevious: boolean): sap.ui.unified.calendar.Header;

          /**
           * Sets a new value for property <code>textButton0</code>.Text of the first button (normally day)When
           * called with a value of <code>null</code> or <code>undefined</code>, the default value of the
           * property will be restored.
           * @since 1.32.0
           * @param sTextButton0 New value for property <code>textButton0</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setTextButton0(sTextButton0: string): sap.ui.unified.calendar.Header;

          /**
           * Sets a new value for property <code>textButton1</code>.Text of the second button (normally
           * month)When called with a value of <code>null</code> or <code>undefined</code>, the default value of
           * the property will be restored.
           * @param sTextButton1 New value for property <code>textButton1</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setTextButton1(sTextButton1: string): sap.ui.unified.calendar.Header;

          /**
           * Sets a new value for property <code>textButton2</code>.Text of the third button (normally year)When
           * called with a value of <code>null</code> or <code>undefined</code>, the default value of the
           * property will be restored.
           * @param sTextButton2 New value for property <code>textButton2</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setTextButton2(sTextButton2: string): sap.ui.unified.calendar.Header;

          /**
           * Sets a new value for property <code>visibleButton0</code>.If set, the first button will be
           * displayed<b>Note:</b> The default is set to false to be compatible to older versionsWhen called with
           * a value of <code>null</code> or <code>undefined</code>, the default value of the property will be
           * restored.Default value is <code>false</code>.
           * @since 1.32.0
           * @param bVisibleButton0 New value for property <code>visibleButton0</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setVisibleButton0(bVisibleButton0: boolean): sap.ui.unified.calendar.Header;

          /**
           * Sets a new value for property <code>visibleButton1</code>.If set, the second button will be
           * displayedWhen called with a value of <code>null</code> or <code>undefined</code>, the default value
           * of the property will be restored.Default value is <code>true</code>.
           * @since 1.32.0
           * @param bVisibleButton1 New value for property <code>visibleButton1</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setVisibleButton1(bVisibleButton1: boolean): sap.ui.unified.calendar.Header;

          /**
           * Sets a new value for property <code>visibleButton2</code>.If set, the third button will be
           * displayedWhen called with a value of <code>null</code> or <code>undefined</code>, the default value
           * of the property will be restored.Default value is <code>true</code>.
           * @since 1.32.0
           * @param bVisibleButton2 New value for property <code>visibleButton2</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setVisibleButton2(bVisibleButton2: boolean): sap.ui.unified.calendar.Header;
        }
        /**
         * Renders a row of time items using ItemNavigation. There is no paging or navigation outside the
         * rendered area implemented.This is done inside the CalendarTimeInterval.If used inside the
         * CalendarTimeInterval the properties and aggregation are directly taken from the parent(to not
         * duplicate and synchronize DateRanges and so on...).The TimesRow works with JavaScript Date objects.
         * @resource sap/ui/unified/calendar/TimesRow.js
        */
        export class TimesRow extends sap.ui.core.Control {


          /**
           * Constructor for a new <code>TimesRow</code>.It shows a calendar with time granularity (normally
           * hours)<b>Note:</b> This is used inside the CalendarTimeInterval, not for standalone usage.Accepts an
           * object literal <code>mSettings</code> that defines initialproperty values, aggregated and associated
           * objects as well as event handlers.See {@link sap.ui.base.ManagedObject#constructor} for a general
           * description of the syntax of the settings object.
           * @param sId ID for the new control, generated automatically if no ID is given
           * @param mSettings Initial settings for the new control
          */
          constructor(sId: string, mSettings?: any);



          /**
           * Adds some ariaLabelledBy into the association <code>ariaLabelledBy</code>.
           * @param vAriaLabelledBy the ariaLabelledBy to add; if empty, nothing is inserted
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          addAriaLabelledBy(vAriaLabelledBy: any | sap.ui.core.Control): sap.ui.unified.calendar.TimesRow;

          /**
           * Adds some selectedDate to the aggregation <code>selectedDates</code>.
           * @param oSelectedDate the selectedDate to add; if empty, nothing is inserted
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          addSelectedDate(oSelectedDate: sap.ui.unified.DateRange): sap.ui.unified.calendar.TimesRow;

          /**
           * Adds some specialDate to the aggregation <code>specialDates</code>.
           * @param oSpecialDate the specialDate to add; if empty, nothing is inserted
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          addSpecialDate(oSpecialDate: sap.ui.unified.DateTypeRange): sap.ui.unified.calendar.TimesRow;

          /**
           * Attaches event handler <code>fnFunction</code> to the <code>focus</code> event of this
           * <code>sap.ui.unified.calendar.TimesRow</code>.When called, the context of the event handler (its
           * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
           * to this <code>sap.ui.unified.calendar.TimesRow</code> itself.Time focus changed
           * @param oData An application-specific payload object that will be passed to the event handler along
           * with the event object when firing the event
           * @param fnFunction The function to be called when the event occurs
           * @param oListener Context object to call the event handler with. Defaults to this
           * <code>sap.ui.unified.calendar.TimesRow</code> itself
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          attachFocus(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.calendar.TimesRow;

          /**
           * Attaches event handler <code>fnFunction</code> to the <code>select</code> event of this
           * <code>sap.ui.unified.calendar.TimesRow</code>.When called, the context of the event handler (its
           * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
           * to this <code>sap.ui.unified.calendar.TimesRow</code> itself.Time selection changed
           * @param oData An application-specific payload object that will be passed to the event handler along
           * with the event object when firing the event
           * @param fnFunction The function to be called when the event occurs
           * @param oListener Context object to call the event handler with. Defaults to this
           * <code>sap.ui.unified.calendar.TimesRow</code> itself
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          attachSelect(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.calendar.TimesRow;

          /**
           * Checks if a date is focusable in the current rendered output.This means that if it is not rendered,
           * it is not focusable.
           * @param oDate JavaScript Date object for focused date.
           * @returns flag if focusable
          */
          checkDateFocusable(oDate: any): boolean;

          /**
           * Destroys all the selectedDates in the aggregation <code>selectedDates</code>.
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          destroySelectedDates(): sap.ui.unified.calendar.TimesRow;

          /**
           * Destroys all the specialDates in the aggregation <code>specialDates</code>.
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          destroySpecialDates(): sap.ui.unified.calendar.TimesRow;

          /**
           * Detaches event handler <code>fnFunction</code> from the <code>focus</code> event of this
           * <code>sap.ui.unified.calendar.TimesRow</code>.The passed function and listener object must match the
           * ones used for event registration.
           * @param fnFunction The function to be called, when the event occurs
           * @param oListener Context object on which the given function had to be called
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          detachFocus(fnFunction: any, oListener: any): sap.ui.unified.calendar.TimesRow;

          /**
           * Detaches event handler <code>fnFunction</code> from the <code>select</code> event of this
           * <code>sap.ui.unified.calendar.TimesRow</code>.The passed function and listener object must match the
           * ones used for event registration.
           * @param fnFunction The function to be called, when the event occurs
           * @param oListener Context object on which the given function had to be called
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          detachSelect(fnFunction: any, oListener: any): sap.ui.unified.calendar.TimesRow;

          /**
           * Displays the given date without setting the focus
           * @param oDate JavaScript Date object for focused date.
           * @returns <code>this</code> to allow method chaining
          */
          displayDate(oDate: any): sap.ui.unified.calendar.TimesRow;


          /**
           * Fires event <code>focus</code> to attached listeners.Expects the following event
           * parameters:<ul><li><code>date</code> of type <code>object</code>date, as JavaScript Date object, of
           * the focused time.</li><li><code>notVisible</code> of type <code>boolean</code>If set, the focused
           * date is not rendered yet. (This happens by navigating out of the visible area.)</li></ul>
           * @param mArguments The arguments to pass along with the event
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          fireFocus(mArguments: any): sap.ui.unified.calendar.TimesRow;

          /**
           * Fires event <code>select</code> to attached listeners.
           * @param mArguments The arguments to pass along with the event
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          fireSelect(mArguments: any): sap.ui.unified.calendar.TimesRow;

          /**
           * Returns array of IDs of the elements which are the current targets of the association
           * <code>ariaLabelledBy</code>.
          */
          getAriaLabelledBy(): any[];

          /**
           * Gets current value of property <code>date</code>.A date as JavaScript Date object. The month
           * including this date is rendered and this date is focused initially (if no other focus is set).If the
           * date property is not in the range <code>startDate</code> + <code>items</code> in the rendering
           * phase,it is set to the <code>startDate</code>.So after setting the <code>startDate</code> the date
           * should be set to be in the visible range.
           * @returns Value of property <code>date</code>
          */
          getDate(): any;

          /**
           * Gets current value of property <code>intervalMinutes</code>.Size of on time interval in minutes,
           * default is 60 minutes.<b>Note:</b> the start of the interval calculation is always
           * <code>startDat</code> at 00:00.A interval longer then 720 minutes is not allowed. Please use the
           * <code>DatesRow</code> instead.A day must be divisible by this interval size. One interval must not
           * include more than one day.Default value is <code>60</code>.
           * @returns Value of property <code>intervalMinutes</code>
          */
          getIntervalMinutes(): number;

          /**
           * Gets current value of property <code>intervalSelection</code>.If set, interval selection is
           * allowedDefault value is <code>false</code>.
           * @returns Value of property <code>intervalSelection</code>
          */
          getIntervalSelection(): boolean;

          /**
           * Gets current value of property <code>items</code>.Number of time items displayedDefault value is
           * <code>12</code>.
           * @returns Value of property <code>items</code>
          */
          getItems(): number;

          /**
           * ID of the element which is the current target of the association <code>legend</code>, or
           * <code>null</code>.
           * @since 1.38.5
          */
          getLegend(): any;

          /**
           * Returns a metadata object for class sap.ui.unified.calendar.TimesRow.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Gets content of aggregation <code>selectedDates</code>.Date ranges for selected dates.If
           * <code>singleSelection</code> is set, only the first entry is used.
          */
          getSelectedDates(): sap.ui.unified.DateRange[];

          /**
           * Gets current value of property <code>showHeader</code>.If set, a header with the years is shown to
           * visualize what month belongs to what year.Default value is <code>false</code>.
           * @returns Value of property <code>showHeader</code>
          */
          getShowHeader(): boolean;

          /**
           * Gets current value of property <code>singleSelection</code>.If set, only a single month or interval,
           * if intervalSelection is enabled, can be selected<b>Note:</b> Selection of multiple intervals is not
           * supported in the current version.Default value is <code>true</code>.
           * @returns Value of property <code>singleSelection</code>
          */
          getSingleSelection(): boolean;

          /**
           * Gets content of aggregation <code>specialDates</code>.Date ranges with type to visualize special
           * item in the row.If one day is assigned to more than one type, only the first one will be used.
          */
          getSpecialDates(): sap.ui.unified.DateTypeRange[];

          /**
           * Gets current value of property <code>startDate</code>.Start date, as JavaScript Date object, of the
           * row.
           * @returns Value of property <code>startDate</code>
          */
          getStartDate(): any;

          /**
           * Checks for the provided <code>sap.ui.unified.DateRange</code> in the aggregation
           * <code>selectedDates</code>.and returns its index if found or -1 otherwise.
           * @param oSelectedDate The selectedDate whose index is looked for
           * @returns The index of the provided control in the aggregation if found, or -1 otherwise
          */
          indexOfSelectedDate(oSelectedDate: sap.ui.unified.DateRange): number;

          /**
           * Checks for the provided <code>sap.ui.unified.DateTypeRange</code> in the aggregation
           * <code>specialDates</code>.and returns its index if found or -1 otherwise.
           * @param oSpecialDate The specialDate whose index is looked for
           * @returns The index of the provided control in the aggregation if found, or -1 otherwise
          */
          indexOfSpecialDate(oSpecialDate: sap.ui.unified.DateTypeRange): number;

          /**
           * Inserts a selectedDate into the aggregation <code>selectedDates</code>.
           * @param oSelectedDate the selectedDate to insert; if empty, nothing is inserted
           * @param iIndex the <code>0</code>-based index the selectedDate should be inserted at; for            
           * a negative value of <code>iIndex</code>, the selectedDate is inserted at position 0; for a value    
           *         greater than the current size of the aggregation, the selectedDate is inserted at           
           *  the last position
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          insertSelectedDate(oSelectedDate: sap.ui.unified.DateRange, iIndex: number): sap.ui.unified.calendar.TimesRow;

          /**
           * Inserts a specialDate into the aggregation <code>specialDates</code>.
           * @param oSpecialDate the specialDate to insert; if empty, nothing is inserted
           * @param iIndex the <code>0</code>-based index the specialDate should be inserted at; for            
           * a negative value of <code>iIndex</code>, the specialDate is inserted at position 0; for a value     
           *        greater than the current size of the aggregation, the specialDate is inserted at            
           * the last position
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          insertSpecialDate(oSpecialDate: sap.ui.unified.DateTypeRange, iIndex: number): sap.ui.unified.calendar.TimesRow;

          /**
           * Removes all the controls in the association named <code>ariaLabelledBy</code>.
           * @returns An array of the removed elements (might be empty)
          */
          removeAllAriaLabelledBy(): any[];

          /**
           * Removes all the controls from the aggregation <code>selectedDates</code>.Additionally, it
           * unregisters them from the hosting UIArea.
           * @returns An array of the removed elements (might be empty)
          */
          removeAllSelectedDates(): sap.ui.unified.DateRange[];

          /**
           * Removes all the controls from the aggregation <code>specialDates</code>.Additionally, it unregisters
           * them from the hosting UIArea.
           * @returns An array of the removed elements (might be empty)
          */
          removeAllSpecialDates(): sap.ui.unified.DateTypeRange[];

          /**
           * Removes an ariaLabelledBy from the association named <code>ariaLabelledBy</code>.
           * @param vAriaLabelledBy The ariaLabelledBy to be removed or its index or ID
           * @returns The removed ariaLabelledBy or <code>null</code>
          */
          removeAriaLabelledBy(vAriaLabelledBy: number | any | sap.ui.core.Control): any;

          /**
           * Removes a selectedDate from the aggregation <code>selectedDates</code>.
           * @param vSelectedDate The selectedDate to remove or its index or id
           * @returns The removed selectedDate or <code>null</code>
          */
          removeSelectedDate(vSelectedDate: number | string | sap.ui.unified.DateRange): sap.ui.unified.DateRange;

          /**
           * Removes a specialDate from the aggregation <code>specialDates</code>.
           * @param vSpecialDate The specialDate to remove or its index or id
           * @returns The removed specialDate or <code>null</code>
          */
          removeSpecialDate(vSpecialDate: number | string | sap.ui.unified.DateTypeRange): sap.ui.unified.DateTypeRange;

          /**
           * Sets a new value for property <code>date</code>.A date as JavaScript Date object. The month
           * including this date is rendered and this date is focused initially (if no other focus is set).If the
           * date property is not in the range <code>startDate</code> + <code>items</code> in the rendering
           * phase,it is set to the <code>startDate</code>.So after setting the <code>startDate</code> the date
           * should be set to be in the visible range.When called with a value of <code>null</code> or
           * <code>undefined</code>, the default value of the property will be restored.
           * @param oDate New value for property <code>date</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setDate(oDate: any): sap.ui.unified.calendar.TimesRow;

          /**
           * Sets a new value for property <code>intervalMinutes</code>.Size of on time interval in minutes,
           * default is 60 minutes.<b>Note:</b> the start of the interval calculation is always
           * <code>startDat</code> at 00:00.A interval longer then 720 minutes is not allowed. Please use the
           * <code>DatesRow</code> instead.A day must be divisible by this interval size. One interval must not
           * include more than one day.When called with a value of <code>null</code> or <code>undefined</code>,
           * the default value of the property will be restored.Default value is <code>60</code>.
           * @param iIntervalMinutes New value for property <code>intervalMinutes</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setIntervalMinutes(iIntervalMinutes: number): sap.ui.unified.calendar.TimesRow;

          /**
           * Sets a new value for property <code>intervalSelection</code>.If set, interval selection is
           * allowedWhen called with a value of <code>null</code> or <code>undefined</code>, the default value of
           * the property will be restored.Default value is <code>false</code>.
           * @param bIntervalSelection New value for property <code>intervalSelection</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setIntervalSelection(bIntervalSelection: boolean): sap.ui.unified.calendar.TimesRow;

          /**
           * Sets a new value for property <code>items</code>.Number of time items displayedWhen called with a
           * value of <code>null</code> or <code>undefined</code>, the default value of the property will be
           * restored.Default value is <code>12</code>.
           * @param iItems New value for property <code>items</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setItems(iItems: number): sap.ui.unified.calendar.TimesRow;

          /**
           * Sets the associated <code>legend</code>.
           * @since 1.38.5
           * @param oLegend ID of an element which becomes the new target of this legend association;
           * alternatively, an element instance may be given
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setLegend(oLegend: any | sap.ui.unified.CalendarLegend): sap.ui.unified.calendar.TimesRow;

          /**
           * Sets a new value for property <code>showHeader</code>.If set, a header with the years is shown to
           * visualize what month belongs to what year.When called with a value of <code>null</code> or
           * <code>undefined</code>, the default value of the property will be restored.Default value is
           * <code>false</code>.
           * @param bShowHeader New value for property <code>showHeader</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setShowHeader(bShowHeader: boolean): sap.ui.unified.calendar.TimesRow;

          /**
           * Sets a new value for property <code>singleSelection</code>.If set, only a single month or interval,
           * if intervalSelection is enabled, can be selected<b>Note:</b> Selection of multiple intervals is not
           * supported in the current version.When called with a value of <code>null</code> or
           * <code>undefined</code>, the default value of the property will be restored.Default value is
           * <code>true</code>.
           * @param bSingleSelection New value for property <code>singleSelection</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setSingleSelection(bSingleSelection: boolean): sap.ui.unified.calendar.TimesRow;

          /**
           * Sets a new value for property <code>startDate</code>.Start date, as JavaScript Date object, of the
           * row.When called with a value of <code>null</code> or <code>undefined</code>, the default value of
           * the property will be restored.
           * @param oStartDate New value for property <code>startDate</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setStartDate(oStartDate: any): sap.ui.unified.calendar.TimesRow;
        }
        /**
         * renders a row of days with ItemNavigationThis is used inside the calendar. Not for stand alone
         * usageIf used inside the calendar the properties and aggregation are directly taken from the
         * parent(To not duplicate and sync DateRanges and so on...)
         * @resource sap/ui/unified/calendar/DatesRow.js
        */
        export class DatesRow extends sap.ui.unified.calendar.Month {


          /**
           * Constructor for a new calendar/DatesRow.Accepts an object literal <code>mSettings</code> that
           * defines initialproperty values, aggregated and associated objects as well as event handlers.See
           * {@link sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the
           * settings object.
           * @param sId id for the new control, generated automatically if no id is given
           * @param mSettings initial settings for the new control
          */
          constructor(sId: string, mSettings?: any);



          /**
           * displays the a given date without setting the focusProperty <code>date</code> date to be focused or
           * displayed. It must be in the displayed date rangebeginning with <code>startDate</code> and
           * <code>days</code> daysSo set this properties before setting the date.
           * @param oDate JavaScript date object for focused date.
           * @returns <code>this</code> to allow method chaining
          */
          displayDate(oDate: any): sap.ui.unified.calendar.Month;


          /**
           * Gets current value of property <code>days</code>.number of days displayedDefault value is
           * <code>7</code>.
           * @returns Value of property <code>days</code>
          */
          getDays(): number;

          /**
           * Returns a metadata object for class sap.ui.unified.calendar.DatesRow.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Gets current value of property <code>showDayNamesLine</code>.If set the day names are shown in a
           * separate line.If not set the day names are shown inside the single days.Default value is
           * <code>true</code>.
           * @since 1.34.0
           * @returns Value of property <code>showDayNamesLine</code>
          */
          getShowDayNamesLine(): boolean;

          /**
           * Gets current value of property <code>startDate</code>.Start date of the rowIf in rendering phase the
           * date property is not in the range startDate + days,it is set to the start dateSo after setting the
           * start date the date should be set to be in the range of the start date
           * @returns Value of property <code>startDate</code>
          */
          getStartDate(): any;

          /**
           * Setter for property <code>date</code>.Property <code>date</code> date to be focused or displayed. It
           * must be in the displayed date rangebeginning with <code>startDate</code> and <code>days</code>
           * daysSo set this properties before setting the date.
           * @param oDate JavaScript date object for start date.
           * @returns <code>this</code> to allow method chaining
          */
          setDate(oDate: any): sap.ui.unified.calendar.DatesRow;

          /**
           * Sets a new value for property <code>days</code>.number of days displayedWhen called with a value of
           * <code>null</code> or <code>undefined</code>, the default value of the property will be
           * restored.Default value is <code>7</code>.
           * @param iDays New value for property <code>days</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setDays(iDays: number): sap.ui.unified.calendar.DatesRow;

          /**
           * Setter for property <code>firstDayOfWeek</code>.Property <code>firstDayOfWeek</code> is not
           * supported in <code>sap.ui.unified.calendar.DatesRow</code> control.
           * @param iFirstDayOfWeek first day of the week
          */
          setFirstDayOfWeek(iFirstDayOfWeek: number): void;

          /**
           * Sets a new value for property <code>showDayNamesLine</code>.If set the day names are shown in a
           * separate line.If not set the day names are shown inside the single days.When called with a value of
           * <code>null</code> or <code>undefined</code>, the default value of the property will be
           * restored.Default value is <code>true</code>.
           * @since 1.34.0
           * @param bShowDayNamesLine New value for property <code>showDayNamesLine</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setShowDayNamesLine(bShowDayNamesLine: boolean): sap.ui.unified.calendar.DatesRow;

          /**
           * Sets a new value for property <code>startDate</code>.Start date of the rowIf in rendering phase the
           * date property is not in the range startDate + days,it is set to the start dateSo after setting the
           * start date the date should be set to be in the range of the start dateWhen called with a value of
           * <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
           * @param oStartDate New value for property <code>startDate</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setStartDate(oStartDate: any): sap.ui.unified.calendar.DatesRow;
        }
        /**
         * Renders a row of months using ItemNavigation. There is no paging or navigation outside the rendered
         * area implemented.This is done inside the CalendarMonthInterval.If used inside the
         * CalendarMonthInterval the properties and aggregation are directly taken from the parent(to not
         * duplicate and synchronize DateRanges and so on...).The MontsRow works with JavaScript Date objects,
         * but only the month and the year are used to display and interact.As representation for a month, the
         * 1st of the month will always be returned in the API.
         * @resource sap/ui/unified/calendar/MonthsRow.js
        */
        export class MonthsRow extends sap.ui.core.Control {


          /**
           * Constructor for a new <code>MonthsRow</code>.It shows a calendar with month granularity<b>Note:</b>
           * This is used inside the CalendarMonthInterval, not for standalone usage.Accepts an object literal
           * <code>mSettings</code> that defines initialproperty values, aggregated and associated objects as
           * well as event handlers.See {@link sap.ui.base.ManagedObject#constructor} for a general description
           * of the syntax of the settings object.
           * @param sId ID for the new control, generated automatically if no ID is given
           * @param mSettings Initial settings for the new control
          */
          constructor(sId: string, mSettings?: any);



          /**
           * Adds some ariaLabelledBy into the association <code>ariaLabelledBy</code>.
           * @param vAriaLabelledBy the ariaLabelledBy to add; if empty, nothing is inserted
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          addAriaLabelledBy(vAriaLabelledBy: any | sap.ui.core.Control): sap.ui.unified.calendar.MonthsRow;

          /**
           * Adds some selectedDate to the aggregation <code>selectedDates</code>.
           * @param oSelectedDate the selectedDate to add; if empty, nothing is inserted
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          addSelectedDate(oSelectedDate: sap.ui.unified.DateRange): sap.ui.unified.calendar.MonthsRow;

          /**
           * Adds some specialDate to the aggregation <code>specialDates</code>.
           * @param oSpecialDate the specialDate to add; if empty, nothing is inserted
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          addSpecialDate(oSpecialDate: sap.ui.unified.DateTypeRange): sap.ui.unified.calendar.MonthsRow;

          /**
           * Attaches event handler <code>fnFunction</code> to the <code>focus</code> event of this
           * <code>sap.ui.unified.calendar.MonthsRow</code>.When called, the context of the event handler (its
           * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
           * to this <code>sap.ui.unified.calendar.MonthsRow</code> itself.Month focus changed
           * @param oData An application-specific payload object that will be passed to the event handler along
           * with the event object when firing the event
           * @param fnFunction The function to be called when the event occurs
           * @param oListener Context object to call the event handler with. Defaults to this
           * <code>sap.ui.unified.calendar.MonthsRow</code> itself
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          attachFocus(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.calendar.MonthsRow;

          /**
           * Attaches event handler <code>fnFunction</code> to the <code>select</code> event of this
           * <code>sap.ui.unified.calendar.MonthsRow</code>.When called, the context of the event handler (its
           * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
           * to this <code>sap.ui.unified.calendar.MonthsRow</code> itself.Month selection changed
           * @param oData An application-specific payload object that will be passed to the event handler along
           * with the event object when firing the event
           * @param fnFunction The function to be called when the event occurs
           * @param oListener Context object to call the event handler with. Defaults to this
           * <code>sap.ui.unified.calendar.MonthsRow</code> itself
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          attachSelect(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.calendar.MonthsRow;

          /**
           * Checks if a date is focusable in the current rendered output.This means that if it is not rendered,
           * it is not focusable.
           * @param oDate JavaScript Date object for focused date.
           * @returns flag if focusable
          */
          checkDateFocusable(oDate: any): boolean;

          /**
           * Destroys all the selectedDates in the aggregation <code>selectedDates</code>.
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          destroySelectedDates(): sap.ui.unified.calendar.MonthsRow;

          /**
           * Destroys all the specialDates in the aggregation <code>specialDates</code>.
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          destroySpecialDates(): sap.ui.unified.calendar.MonthsRow;

          /**
           * Detaches event handler <code>fnFunction</code> from the <code>focus</code> event of this
           * <code>sap.ui.unified.calendar.MonthsRow</code>.The passed function and listener object must match
           * the ones used for event registration.
           * @param fnFunction The function to be called, when the event occurs
           * @param oListener Context object on which the given function had to be called
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          detachFocus(fnFunction: any, oListener: any): sap.ui.unified.calendar.MonthsRow;

          /**
           * Detaches event handler <code>fnFunction</code> from the <code>select</code> event of this
           * <code>sap.ui.unified.calendar.MonthsRow</code>.The passed function and listener object must match
           * the ones used for event registration.
           * @param fnFunction The function to be called, when the event occurs
           * @param oListener Context object on which the given function had to be called
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          detachSelect(fnFunction: any, oListener: any): sap.ui.unified.calendar.MonthsRow;

          /**
           * Displays the month of a given date without setting the focus
           * @param oDate JavaScript Date object for focused date.
           * @returns <code>this</code> to allow method chaining
          */
          displayDate(oDate: any): sap.ui.unified.calendar.MonthsRow;


          /**
           * Fires event <code>focus</code> to attached listeners.Expects the following event
           * parameters:<ul><li><code>date</code> of type <code>object</code>First date, as JavaScript Date
           * object, of the month that is focused.</li><li><code>notVisible</code> of type <code>boolean</code>If
           * set, the focused date is not rendered yet. (This happens by navigating out of the visible
           * area.)</li></ul>
           * @param mArguments The arguments to pass along with the event
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          fireFocus(mArguments: any): sap.ui.unified.calendar.MonthsRow;

          /**
           * Fires event <code>select</code> to attached listeners.
           * @param mArguments The arguments to pass along with the event
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          fireSelect(mArguments: any): sap.ui.unified.calendar.MonthsRow;

          /**
           * Returns array of IDs of the elements which are the current targets of the association
           * <code>ariaLabelledBy</code>.
          */
          getAriaLabelledBy(): any[];

          /**
           * Gets current value of property <code>date</code>.A date as JavaScript Date object. The month
           * including this date is rendered and this date is focused initially (if no other focus is set).If the
           * date property is not in the range <code>startDate</code> + <code>months</code> in the rendering
           * phase,it is set to the <code>startDate</code>.So after setting the <code>startDate</code> the date
           * should be set to be in the visible range.
           * @returns Value of property <code>date</code>
          */
          getDate(): any;

          /**
           * Gets current value of property <code>intervalSelection</code>.If set, interval selection is
           * allowedDefault value is <code>false</code>.
           * @returns Value of property <code>intervalSelection</code>
          */
          getIntervalSelection(): boolean;

          /**
           * ID of the element which is the current target of the association <code>legend</code>, or
           * <code>null</code>.
           * @since 1.38.5
          */
          getLegend(): any;

          /**
           * Returns a metadata object for class sap.ui.unified.calendar.MonthsRow.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Gets current value of property <code>months</code>.Number of months displayedDefault value is
           * <code>12</code>.
           * @returns Value of property <code>months</code>
          */
          getMonths(): number;

          /**
           * Gets content of aggregation <code>selectedDates</code>.Date ranges for selected dates.If
           * <code>singleSelection</code> is set, only the first entry is used.<b>Note:</b> Even if only one day
           * is selected, the whole corresponding month is selected.
          */
          getSelectedDates(): sap.ui.unified.DateRange[];

          /**
           * Gets current value of property <code>showHeader</code>.If set, a header with the years is shown to
           * visualize what month belongs to what year.Default value is <code>false</code>.
           * @returns Value of property <code>showHeader</code>
          */
          getShowHeader(): boolean;

          /**
           * Gets current value of property <code>singleSelection</code>.If set, only a single month or interval,
           * if intervalSelection is enabled, can be selected<b>Note:</b> Selection of multiple intervals is not
           * supported in the current version.Default value is <code>true</code>.
           * @returns Value of property <code>singleSelection</code>
          */
          getSingleSelection(): boolean;

          /**
           * Gets content of aggregation <code>specialDates</code>.Date ranges with type to visualize special
           * months in the row.If one day is assigned to more than one type, only the first one will be
           * used.<b>Note:</b> Even if only one day is set as a special day, the whole corresponding month is
           * displayed in this way.
          */
          getSpecialDates(): sap.ui.unified.DateTypeRange[];

          /**
           * Gets current value of property <code>startDate</code>.Start date, as JavaScript Date object, of the
           * row. The month of this date is the first month of the displayed row.
           * @returns Value of property <code>startDate</code>
          */
          getStartDate(): any;

          /**
           * Checks for the provided <code>sap.ui.unified.DateRange</code> in the aggregation
           * <code>selectedDates</code>.and returns its index if found or -1 otherwise.
           * @param oSelectedDate The selectedDate whose index is looked for
           * @returns The index of the provided control in the aggregation if found, or -1 otherwise
          */
          indexOfSelectedDate(oSelectedDate: sap.ui.unified.DateRange): number;

          /**
           * Checks for the provided <code>sap.ui.unified.DateTypeRange</code> in the aggregation
           * <code>specialDates</code>.and returns its index if found or -1 otherwise.
           * @param oSpecialDate The specialDate whose index is looked for
           * @returns The index of the provided control in the aggregation if found, or -1 otherwise
          */
          indexOfSpecialDate(oSpecialDate: sap.ui.unified.DateTypeRange): number;

          /**
           * Inserts a selectedDate into the aggregation <code>selectedDates</code>.
           * @param oSelectedDate the selectedDate to insert; if empty, nothing is inserted
           * @param iIndex the <code>0</code>-based index the selectedDate should be inserted at; for            
           * a negative value of <code>iIndex</code>, the selectedDate is inserted at position 0; for a value    
           *         greater than the current size of the aggregation, the selectedDate is inserted at           
           *  the last position
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          insertSelectedDate(oSelectedDate: sap.ui.unified.DateRange, iIndex: number): sap.ui.unified.calendar.MonthsRow;

          /**
           * Inserts a specialDate into the aggregation <code>specialDates</code>.
           * @param oSpecialDate the specialDate to insert; if empty, nothing is inserted
           * @param iIndex the <code>0</code>-based index the specialDate should be inserted at; for            
           * a negative value of <code>iIndex</code>, the specialDate is inserted at position 0; for a value     
           *        greater than the current size of the aggregation, the specialDate is inserted at            
           * the last position
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          insertSpecialDate(oSpecialDate: sap.ui.unified.DateTypeRange, iIndex: number): sap.ui.unified.calendar.MonthsRow;

          /**
           * Removes all the controls in the association named <code>ariaLabelledBy</code>.
           * @returns An array of the removed elements (might be empty)
          */
          removeAllAriaLabelledBy(): any[];

          /**
           * Removes all the controls from the aggregation <code>selectedDates</code>.Additionally, it
           * unregisters them from the hosting UIArea.
           * @returns An array of the removed elements (might be empty)
          */
          removeAllSelectedDates(): sap.ui.unified.DateRange[];

          /**
           * Removes all the controls from the aggregation <code>specialDates</code>.Additionally, it unregisters
           * them from the hosting UIArea.
           * @returns An array of the removed elements (might be empty)
          */
          removeAllSpecialDates(): sap.ui.unified.DateTypeRange[];

          /**
           * Removes an ariaLabelledBy from the association named <code>ariaLabelledBy</code>.
           * @param vAriaLabelledBy The ariaLabelledBy to be removed or its index or ID
           * @returns The removed ariaLabelledBy or <code>null</code>
          */
          removeAriaLabelledBy(vAriaLabelledBy: number | any | sap.ui.core.Control): any;

          /**
           * Removes a selectedDate from the aggregation <code>selectedDates</code>.
           * @param vSelectedDate The selectedDate to remove or its index or id
           * @returns The removed selectedDate or <code>null</code>
          */
          removeSelectedDate(vSelectedDate: number | string | sap.ui.unified.DateRange): sap.ui.unified.DateRange;

          /**
           * Removes a specialDate from the aggregation <code>specialDates</code>.
           * @param vSpecialDate The specialDate to remove or its index or id
           * @returns The removed specialDate or <code>null</code>
          */
          removeSpecialDate(vSpecialDate: number | string | sap.ui.unified.DateTypeRange): sap.ui.unified.DateTypeRange;

          /**
           * Sets a new value for property <code>date</code>.A date as JavaScript Date object. The month
           * including this date is rendered and this date is focused initially (if no other focus is set).If the
           * date property is not in the range <code>startDate</code> + <code>months</code> in the rendering
           * phase,it is set to the <code>startDate</code>.So after setting the <code>startDate</code> the date
           * should be set to be in the visible range.When called with a value of <code>null</code> or
           * <code>undefined</code>, the default value of the property will be restored.
           * @param oDate New value for property <code>date</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setDate(oDate: any): sap.ui.unified.calendar.MonthsRow;

          /**
           * Sets a new value for property <code>intervalSelection</code>.If set, interval selection is
           * allowedWhen called with a value of <code>null</code> or <code>undefined</code>, the default value of
           * the property will be restored.Default value is <code>false</code>.
           * @param bIntervalSelection New value for property <code>intervalSelection</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setIntervalSelection(bIntervalSelection: boolean): sap.ui.unified.calendar.MonthsRow;

          /**
           * Sets the associated <code>legend</code>.
           * @since 1.38.5
           * @param oLegend ID of an element which becomes the new target of this legend association;
           * alternatively, an element instance may be given
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setLegend(oLegend: any | sap.ui.unified.CalendarLegend): sap.ui.unified.calendar.MonthsRow;

          /**
           * Sets a new value for property <code>months</code>.Number of months displayedWhen called with a value
           * of <code>null</code> or <code>undefined</code>, the default value of the property will be
           * restored.Default value is <code>12</code>.
           * @param iMonths New value for property <code>months</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setMonths(iMonths: number): sap.ui.unified.calendar.MonthsRow;

          /**
           * Sets a new value for property <code>showHeader</code>.If set, a header with the years is shown to
           * visualize what month belongs to what year.When called with a value of <code>null</code> or
           * <code>undefined</code>, the default value of the property will be restored.Default value is
           * <code>false</code>.
           * @param bShowHeader New value for property <code>showHeader</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setShowHeader(bShowHeader: boolean): sap.ui.unified.calendar.MonthsRow;

          /**
           * Sets a new value for property <code>singleSelection</code>.If set, only a single month or interval,
           * if intervalSelection is enabled, can be selected<b>Note:</b> Selection of multiple intervals is not
           * supported in the current version.When called with a value of <code>null</code> or
           * <code>undefined</code>, the default value of the property will be restored.Default value is
           * <code>true</code>.
           * @param bSingleSelection New value for property <code>singleSelection</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setSingleSelection(bSingleSelection: boolean): sap.ui.unified.calendar.MonthsRow;

          /**
           * Sets a new value for property <code>startDate</code>.Start date, as JavaScript Date object, of the
           * row. The month of this date is the first month of the displayed row.When called with a value of
           * <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
           * @param oStartDate New value for property <code>startDate</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setStartDate(oStartDate: any): sap.ui.unified.calendar.MonthsRow;
        }
        /**
         * renders a YearPicker with ItemNavigationThis is used inside the calendar. Not for stand alone usage
         * @resource sap/ui/unified/calendar/YearPicker.js
        */
        export class YearPicker extends sap.ui.core.Control {


          /**
           * Constructor for a new YearPicker.Accepts an object literal <code>mSettings</code> that defines
           * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
           * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
           * object.
           * @param sId id for the new control, generated automatically if no id is given
           * @param mSettings initial settings for the new control
          */
          constructor(sId: string, mSettings?: any);



          /**
           * Attaches event handler <code>fnFunction</code> to the <code>pageChange</code> event of this
           * <code>sap.ui.unified.calendar.YearPicker</code>.When called, the context of the event handler (its
           * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
           * to this <code>sap.ui.unified.calendar.YearPicker</code> itself.The <code>pageChange</code> event is
           * fired if the displayed years are changed by user navigation.
           * @since 1.38.0
           * @param oData An application-specific payload object that will be passed to the event handler along
           * with the event object when firing the event
           * @param fnFunction The function to be called when the event occurs
           * @param oListener Context object to call the event handler with. Defaults to this
           * <code>sap.ui.unified.calendar.YearPicker</code> itself
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          attachPageChange(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.calendar.YearPicker;

          /**
           * Attaches event handler <code>fnFunction</code> to the <code>select</code> event of this
           * <code>sap.ui.unified.calendar.YearPicker</code>.When called, the context of the event handler (its
           * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
           * to this <code>sap.ui.unified.calendar.YearPicker</code> itself.Month selection changed
           * @param oData An application-specific payload object that will be passed to the event handler along
           * with the event object when firing the event
           * @param fnFunction The function to be called when the event occurs
           * @param oListener Context object to call the event handler with. Defaults to this
           * <code>sap.ui.unified.calendar.YearPicker</code> itself
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          attachSelect(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.calendar.YearPicker;

          /**
           * Detaches event handler <code>fnFunction</code> from the <code>pageChange</code> event of this
           * <code>sap.ui.unified.calendar.YearPicker</code>.The passed function and listener object must match
           * the ones used for event registration.
           * @since 1.38.0
           * @param fnFunction The function to be called, when the event occurs
           * @param oListener Context object on which the given function had to be called
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          detachPageChange(fnFunction: any, oListener: any): sap.ui.unified.calendar.YearPicker;

          /**
           * Detaches event handler <code>fnFunction</code> from the <code>select</code> event of this
           * <code>sap.ui.unified.calendar.YearPicker</code>.The passed function and listener object must match
           * the ones used for event registration.
           * @param fnFunction The function to be called, when the event occurs
           * @param oListener Context object on which the given function had to be called
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          detachSelect(fnFunction: any, oListener: any): sap.ui.unified.calendar.YearPicker;


          /**
           * Fires event <code>pageChange</code> to attached listeners.
           * @since 1.38.0
           * @param mArguments The arguments to pass along with the event
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          firePageChange(mArguments: any): sap.ui.unified.calendar.YearPicker;

          /**
           * Fires event <code>select</code> to attached listeners.
           * @param mArguments The arguments to pass along with the event
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          fireSelect(mArguments: any): sap.ui.unified.calendar.YearPicker;

          /**
           * Gets current value of property <code>columns</code>.number of years in each row0 means just to have
           * all years in one row, independent of the numberDefault value is <code>4</code>.
           * @since 1.30.0
           * @returns Value of property <code>columns</code>
          */
          getColumns(): number;

          /**
           * Gets current value of property <code>date</code>.Date as JavaScript Date object. For this date a
           * <code>YearPicker</code> is rendered. If a Year is selected thedate is updated with the start date of
           * the selected year (depending on the calendar type).
           * @since 1.34.0
           * @returns Value of property <code>date</code>
          */
          getDate(): any;

          /**
           * return the first date of the first rendered year<b>Note:</b> If the YearPicker is not rendered no
           * date is returned
           * @since 1.38.0
           * @returns JavaScript Date Object
          */
          getFirstRenderedDate(): any;

          /**
           * Returns a metadata object for class sap.ui.unified.calendar.YearPicker.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Gets current value of property <code>primaryCalendarType</code>.If set, the calendar type is used
           * for display.If not set, the calendar type of the global configuration is used.
           * @since 1.34.0
           * @returns Value of property <code>primaryCalendarType</code>
          */
          getPrimaryCalendarType(): sap.ui.core.CalendarType;

          /**
           * Gets current value of property <code>year</code>.The year is initial focused and selectedThe value
           * must be between 0 and 9999Default value is <code>2000</code>.
           * @returns Value of property <code>year</code>
          */
          getYear(): number;

          /**
           * Gets current value of property <code>years</code>.number of displayed yearsDefault value is
           * <code>20</code>.
           * @since 1.30.0
           * @returns Value of property <code>years</code>
          */
          getYears(): number;

          /**
           * displays the next page
           * @returns <code>this</code> to allow method chaining
          */
          nextPage(): sap.ui.unified.calendar.YearPicker;

          /**
           * displays the previous page
           * @returns <code>this</code> to allow method chaining
          */
          previousPage(): sap.ui.unified.calendar.YearPicker;

          /**
           * Sets a new value for property <code>columns</code>.number of years in each row0 means just to have
           * all years in one row, independent of the numberWhen called with a value of <code>null</code> or
           * <code>undefined</code>, the default value of the property will be restored.Default value is
           * <code>4</code>.
           * @since 1.30.0
           * @param iColumns New value for property <code>columns</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setColumns(iColumns: number): sap.ui.unified.calendar.YearPicker;

          /**
           * Sets a new value for property <code>date</code>.Date as JavaScript Date object. For this date a
           * <code>YearPicker</code> is rendered. If a Year is selected thedate is updated with the start date of
           * the selected year (depending on the calendar type).When called with a value of <code>null</code> or
           * <code>undefined</code>, the default value of the property will be restored.
           * @since 1.34.0
           * @param oDate New value for property <code>date</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setDate(oDate: any): sap.ui.unified.calendar.YearPicker;

          /**
           * Sets a new value for property <code>primaryCalendarType</code>.If set, the calendar type is used for
           * display.If not set, the calendar type of the global configuration is used.When called with a value
           * of <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
           * @since 1.34.0
           * @param sPrimaryCalendarType New value for property <code>primaryCalendarType</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setPrimaryCalendarType(sPrimaryCalendarType: sap.ui.core.CalendarType): sap.ui.unified.calendar.YearPicker;

          /**
           * Sets a new value for property <code>year</code>.The year is initial focused and selectedThe value
           * must be between 0 and 9999When called with a value of <code>null</code> or <code>undefined</code>,
           * the default value of the property will be restored.Default value is <code>2000</code>.
           * @param iYear New value for property <code>year</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setYear(iYear: number): sap.ui.unified.calendar.YearPicker;

          /**
           * Sets a new value for property <code>years</code>.number of displayed yearsWhen called with a value
           * of <code>null</code> or <code>undefined</code>, the default value of the property will be
           * restored.Default value is <code>20</code>.
           * @since 1.30.0
           * @param iYears New value for property <code>years</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setYears(iYears: number): sap.ui.unified.calendar.YearPicker;
        }
        /**
         * renders a MonthPicker with ItemNavigationThis is used inside the calendar. Not for stand alone usage
         * @resource sap/ui/unified/calendar/MonthPicker.js
        */
        export class MonthPicker extends sap.ui.core.Control {


          /**
           * Constructor for a new MonthPicker.Accepts an object literal <code>mSettings</code> that defines
           * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
           * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
           * object.
           * @param sId id for the new control, generated automatically if no id is given
           * @param mSettings initial settings for the new control
          */
          constructor(sId: string, mSettings?: any);



          /**
           * Attaches event handler <code>fnFunction</code> to the <code>pageChange</code> event of this
           * <code>sap.ui.unified.calendar.MonthPicker</code>.When called, the context of the event handler (its
           * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
           * to this <code>sap.ui.unified.calendar.MonthPicker</code> itself.If less than 12 months are displayed
           * the <code>pageChange</code> event is firedif the displayed months are changed by user navigation.
           * @since 1.38.0
           * @param oData An application-specific payload object that will be passed to the event handler along
           * with the event object when firing the event
           * @param fnFunction The function to be called when the event occurs
           * @param oListener Context object to call the event handler with. Defaults to this
           * <code>sap.ui.unified.calendar.MonthPicker</code> itself
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          attachPageChange(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.calendar.MonthPicker;

          /**
           * Attaches event handler <code>fnFunction</code> to the <code>select</code> event of this
           * <code>sap.ui.unified.calendar.MonthPicker</code>.When called, the context of the event handler (its
           * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
           * to this <code>sap.ui.unified.calendar.MonthPicker</code> itself.Month selection changed
           * @param oData An application-specific payload object that will be passed to the event handler along
           * with the event object when firing the event
           * @param fnFunction The function to be called when the event occurs
           * @param oListener Context object to call the event handler with. Defaults to this
           * <code>sap.ui.unified.calendar.MonthPicker</code> itself
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          attachSelect(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.calendar.MonthPicker;

          /**
           * Detaches event handler <code>fnFunction</code> from the <code>pageChange</code> event of this
           * <code>sap.ui.unified.calendar.MonthPicker</code>.The passed function and listener object must match
           * the ones used for event registration.
           * @since 1.38.0
           * @param fnFunction The function to be called, when the event occurs
           * @param oListener Context object on which the given function had to be called
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          detachPageChange(fnFunction: any, oListener: any): sap.ui.unified.calendar.MonthPicker;

          /**
           * Detaches event handler <code>fnFunction</code> from the <code>select</code> event of this
           * <code>sap.ui.unified.calendar.MonthPicker</code>.The passed function and listener object must match
           * the ones used for event registration.
           * @param fnFunction The function to be called, when the event occurs
           * @param oListener Context object on which the given function had to be called
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          detachSelect(fnFunction: any, oListener: any): sap.ui.unified.calendar.MonthPicker;


          /**
           * Fires event <code>pageChange</code> to attached listeners.
           * @since 1.38.0
           * @param mArguments The arguments to pass along with the event
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          firePageChange(mArguments: any): sap.ui.unified.calendar.MonthPicker;

          /**
           * Fires event <code>select</code> to attached listeners.
           * @param mArguments The arguments to pass along with the event
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          fireSelect(mArguments: any): sap.ui.unified.calendar.MonthPicker;

          /**
           * Gets current value of property <code>columns</code>.number of months in each rowThe value must be
           * between 0 and 12 (0 means just to have all months in one row, independent of the number)Default
           * value is <code>3</code>.
           * @since 1.30.0
           * @returns Value of property <code>columns</code>
          */
          getColumns(): number;

          /**
           * Returns a metadata object for class sap.ui.unified.calendar.MonthPicker.
           * @returns Metadata object describing this class
          */
          getMetadata(): sap.ui.base.Metadata;

          /**
           * Gets current value of property <code>month</code>.The month is initial focused and selectedThe value
           * must be between 0 and 11Default value is <code>0</code>.
           * @returns Value of property <code>month</code>
          */
          getMonth(): number;

          /**
           * Gets current value of property <code>months</code>.number of displayed monthsThe value must be
           * between 1 and 12Default value is <code>12</code>.
           * @since 1.30.0
           * @returns Value of property <code>months</code>
          */
          getMonths(): number;

          /**
           * Gets current value of property <code>primaryCalendarType</code>.If set, the calendar type is used
           * for display.If not set, the calendar type of the global configuration is used.
           * @since 1.34.0
           * @returns Value of property <code>primaryCalendarType</code>
          */
          getPrimaryCalendarType(): sap.ui.core.CalendarType;

          /**
           * displays the next page
           * @returns <code>this</code> to allow method chaining
          */
          nextPage(): sap.ui.unified.calendar.MonthPicker;

          /**
           * displays the previous page
           * @returns <code>this</code> to allow method chaining
          */
          previousPage(): sap.ui.unified.calendar.MonthPicker;

          /**
           * Sets a new value for property <code>columns</code>.number of months in each rowThe value must be
           * between 0 and 12 (0 means just to have all months in one row, independent of the number)When called
           * with a value of <code>null</code> or <code>undefined</code>, the default value of the property will
           * be restored.Default value is <code>3</code>.
           * @since 1.30.0
           * @param iColumns New value for property <code>columns</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setColumns(iColumns: number): sap.ui.unified.calendar.MonthPicker;

          /**
           * sets a minimum an maximum month
           * @param iMin minimum month as integer (starting with 0)
           * @param iMax maximum month as integer (starting with 0)
           * @returns <code>this</code> to allow method chaining
          */
          setMinMax(iMin: number, iMax?: number): sap.ui.unified.calendar.MonthPicker;

          /**
           * Sets a new value for property <code>month</code>.The month is initial focused and selectedThe value
           * must be between 0 and 11When called with a value of <code>null</code> or <code>undefined</code>, the
           * default value of the property will be restored.Default value is <code>0</code>.
           * @param iMonth New value for property <code>month</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setMonth(iMonth: number): sap.ui.unified.calendar.MonthPicker;

          /**
           * Sets a new value for property <code>months</code>.number of displayed monthsThe value must be
           * between 1 and 12When called with a value of <code>null</code> or <code>undefined</code>, the default
           * value of the property will be restored.Default value is <code>12</code>.
           * @since 1.30.0
           * @param iMonths New value for property <code>months</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setMonths(iMonths: number): sap.ui.unified.calendar.MonthPicker;

          /**
           * Sets a new value for property <code>primaryCalendarType</code>.If set, the calendar type is used for
           * display.If not set, the calendar type of the global configuration is used.When called with a value
           * of <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
           * @since 1.34.0
           * @param sPrimaryCalendarType New value for property <code>primaryCalendarType</code>
           * @returns Reference to <code>this</code> in order to allow method chaining
          */
          setPrimaryCalendarType(sPrimaryCalendarType: sap.ui.core.CalendarType): sap.ui.unified.calendar.MonthPicker;
        }
      }
      /**
       * A menu is an interactive element which provides a choice of different actions to the user. These
       * actions (items) can also be organized in submenus.Like other dialog-like controls, the menu is not
       * rendered within the control hierarchy. Instead it can be opened at a specified position via a
       * function call.
       * @resource sap/ui/unified/Menu.js
      */
      export class Menu extends sap.ui.core.Control {


        /**
         * Constructor for a new Menu control.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId Id for the new control, generated automatically if no id is given
         * @param mSettings Initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Adds some ariaLabelledBy into the association <code>ariaLabelledBy</code>.
         * @since 1.26.3
         * @param vAriaLabelledBy the ariaLabelledBy to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addAriaLabelledBy(vAriaLabelledBy: any | sap.ui.core.Control): sap.ui.unified.Menu;

        /**
         * Adds some item to the aggregation <code>items</code>.
         * @param oItem the item to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addItem(oItem: sap.ui.unified.MenuItemBase): sap.ui.unified.Menu;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>itemSelect</code> event of this
         * <code>sap.ui.unified.Menu</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.unified.Menu</code> itself.Fired on the root menu of a menu hierarchy whenever
         * a user selects an item within the menu or within one of its direct or indirect submenus.<b>Note:</b>
         * There is also a select event available for each single menu item. This event and the event of the
         * menu items are redundant.
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.unified.Menu</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachItemSelect(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.Menu;

        /**
         * Closes the menu.
        */
        close(): void;

        /**
         * Destroys all the items in the aggregation <code>items</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyItems(): sap.ui.unified.Menu;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>itemSelect</code> event of this
         * <code>sap.ui.unified.Menu</code>.The passed function and listener object must match the ones used
         * for event registration.
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachItemSelect(fnFunction: any, oListener: any): sap.ui.unified.Menu;


        /**
         * Fires event <code>itemSelect</code> to attached listeners.Expects the following event
         * parameters:<ul><li><code>item</code> of type <code>sap.ui.unified.MenuItemBase</code>The action
         * (item) which was selected by the user.</li></ul>
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireItemSelect(mArguments: any): sap.ui.unified.Menu;

        /**
         * Gets current value of property <code>ariaDescription</code>.Accessible label / description of the
         * menu for assistive technologies like screenreaders.
         * @returns Value of property <code>ariaDescription</code>
        */
        getAriaDescription(): string;

        /**
         * Returns array of IDs of the elements which are the current targets of the association
         * <code>ariaLabelledBy</code>.
         * @since 1.26.3
        */
        getAriaLabelledBy(): any[];

        /**
         * Gets current value of property <code>enabled</code>.When a menu is disabled none of its items can be
         * selected by the user.The enabled property of an item (@link sap.ui.unified.MenuItemBase#getEnabled)
         * has no effect when the menu of the item is disabled.Default value is <code>true</code>.
         * @returns Value of property <code>enabled</code>
        */
        getEnabled(): boolean;

        /**
         * Gets content of aggregation <code>items</code>.The available actions to be displayed as items of the
         * menu.
        */
        getItems(): sap.ui.unified.MenuItemBase[];

        /**
         * Gets current value of property <code>maxVisibleItems</code>.The maximum number of items which are
         * displayed before an overflow mechanism takes effect.A value smaller than 1 means an infinite number
         * of visible items.The overall height of the menu is limited by the height of the screen. If the
         * maximum possible height is reached, anoverflow takes effect, even if the maximum number of visible
         * items is not yet reached.Default value is <code>0</code>.
         * @returns Value of property <code>maxVisibleItems</code>
        */
        getMaxVisibleItems(): number;

        /**
         * Returns a metadata object for class sap.ui.unified.Menu.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>pageSize</code>.The keyboard can be used to navigate through
         * the items of a menu. Beside the arrow keys for single steps and the <i>Home</i> / <i>End</i> keys
         * for jumpingto the first / last item, the <i>Page Up</i> / <i>Page Down</i> keys can be used to jump
         * an arbitrary number of items up or down. This number can be defined via the <code>pageSize</code>
         * property.For values smaller than 1, paging behaves in a similar way to when using the <i>Home</i> /
         * <i>End</i> keys. If the value equals 1, the paging behavior is similar to that of the arrow
         * keys.Default value is <code>5</code>.
         * @since 1.25.0
         * @returns Value of property <code>pageSize</code>
        */
        getPageSize(): number;

        /**
         * Checks for the provided <code>sap.ui.unified.MenuItemBase</code> in the aggregation
         * <code>items</code>.and returns its index if found or -1 otherwise.
         * @param oItem The item whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfItem(oItem: sap.ui.unified.MenuItemBase): number;

        /**
         * Inserts a item into the aggregation <code>items</code>.
         * @param oItem the item to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the item should be inserted at; for             a
         * negative value of <code>iIndex</code>, the item is inserted at position 0; for a value            
         * greater than the current size of the aggregation, the item is inserted at             the last
         * position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertItem(oItem: sap.ui.unified.MenuItemBase, iIndex: number): sap.ui.unified.Menu;

        /**
         * Opens the menu at the specified position.The position of the menu is defined relative to an element
         * in the visible DOM by specifyingthe docking location of the menu and of the related element.See
         * {@link sap.ui.core.Popup#open Popup#open} for further details about popup positioning.
         * @param bWithKeyboard Indicates whether or not the first item shall be highlighted when the menu is
         * opened (keyboard case)
         * @param oOpenerRef The element which will get the focus back again after the menu was closed
         * @param sMy The reference docking location of the menu for positioning the menu on the screen
         * @param sAt The 'of' element's reference docking location for positioning the menu on the screen
         * @param oOf The menu is positioned relatively to this element based on the given dock locations
         * @param sOffset The offset relative to the docking point, specified as a string with space-separated
         * pixel values (e.g. "0 10" to move the popup 10 pixels to the right)
         * @param sCollision The collision defines how the position of the menu should be adjusted in case it
         * overflows the window in some direction
        */
        open(bWithKeyboard: boolean, oOpenerRef: sap.ui.core.Element | any, sMy: any, sAt: any, oOf: sap.ui.core.Element | any, sOffset?: string, sCollision?: any): void;

        /**
         * Removes all the controls in the association named <code>ariaLabelledBy</code>.
         * @since 1.26.3
         * @returns An array of the removed elements (might be empty)
        */
        removeAllAriaLabelledBy(): any[];

        /**
         * Removes all the controls from the aggregation <code>items</code>.Additionally, it unregisters them
         * from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllItems(): sap.ui.unified.MenuItemBase[];

        /**
         * Removes an ariaLabelledBy from the association named <code>ariaLabelledBy</code>.
         * @since 1.26.3
         * @param vAriaLabelledBy The ariaLabelledBy to be removed or its index or ID
         * @returns The removed ariaLabelledBy or <code>null</code>
        */
        removeAriaLabelledBy(vAriaLabelledBy: number | any | sap.ui.core.Control): any;

        /**
         * Removes a item from the aggregation <code>items</code>.
         * @param vItem The item to remove or its index or id
         * @returns The removed item or <code>null</code>
        */
        removeItem(vItem: number | string | sap.ui.unified.MenuItemBase): sap.ui.unified.MenuItemBase;

        /**
         * Sets a new value for property <code>ariaDescription</code>.Accessible label / description of the
         * menu for assistive technologies like screenreaders.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.
         * @param sAriaDescription New value for property <code>ariaDescription</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setAriaDescription(sAriaDescription: string): sap.ui.unified.Menu;

        /**
         * Sets a new value for property <code>enabled</code>.When a menu is disabled none of its items can be
         * selected by the user.The enabled property of an item (@link sap.ui.unified.MenuItemBase#getEnabled)
         * has no effect when the menu of the item is disabled.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.Default value is
         * <code>true</code>.
         * @param bEnabled New value for property <code>enabled</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setEnabled(bEnabled: boolean): sap.ui.unified.Menu;

        /**
         * Sets a new value for property <code>maxVisibleItems</code>.The maximum number of items which are
         * displayed before an overflow mechanism takes effect.A value smaller than 1 means an infinite number
         * of visible items.The overall height of the menu is limited by the height of the screen. If the
         * maximum possible height is reached, anoverflow takes effect, even if the maximum number of visible
         * items is not yet reached.When called with a value of <code>null</code> or <code>undefined</code>,
         * the default value of the property will be restored.Default value is <code>0</code>.
         * @param iMaxVisibleItems New value for property <code>maxVisibleItems</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setMaxVisibleItems(iMaxVisibleItems: number): sap.ui.unified.Menu;

        /**
         * Sets a new value for property <code>pageSize</code>.The keyboard can be used to navigate through the
         * items of a menu. Beside the arrow keys for single steps and the <i>Home</i> / <i>End</i> keys for
         * jumpingto the first / last item, the <i>Page Up</i> / <i>Page Down</i> keys can be used to jump an
         * arbitrary number of items up or down. This number can be defined via the <code>pageSize</code>
         * property.For values smaller than 1, paging behaves in a similar way to when using the <i>Home</i> /
         * <i>End</i> keys. If the value equals 1, the paging behavior is similar to that of the arrow
         * keys.When called with a value of <code>null</code> or <code>undefined</code>, the default value of
         * the property will be restored.Default value is <code>5</code>.
         * @since 1.25.0
         * @param iPageSize New value for property <code>pageSize</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setPageSize(iPageSize: number): sap.ui.unified.Menu;
      }
      /**
       * The shell control is meant as root control (full-screen) of an application.It was build as root
       * control of the Fiori Launchpad application and provides the basic capabilitiesfor this purpose. Do
       * not use this control within applications which run inside the Fiori Lauchpad anddo not use it for
       * other scenarios than the root control usecase.
       * @resource sap/ui/unified/Shell.js
      */
      export class Shell extends sap.ui.unified.ShellLayout {


        /**
         * Constructor for a new Shell.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Adds some curtainContent to the aggregation <code>curtainContent</code>.
         * @param oCurtainContent the curtainContent to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addCurtainContent(oCurtainContent: sap.ui.core.Control): sap.ui.unified.Shell;

        /**
         * Adds some curtainPaneContent to the aggregation <code>curtainPaneContent</code>.
         * @param oCurtainPaneContent the curtainPaneContent to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addCurtainPaneContent(oCurtainPaneContent: sap.ui.core.Control): sap.ui.unified.Shell;

        /**
         * Adds some headEndItem to the aggregation <code>headEndItems</code>.
         * @param oHeadEndItem the headEndItem to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addHeadEndItem(oHeadEndItem: sap.ui.unified.ShellHeadItem): sap.ui.unified.Shell;

        /**
         * Adds some headItem to the aggregation <code>headItems</code>.
         * @param oHeadItem the headItem to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addHeadItem(oHeadItem: sap.ui.unified.ShellHeadItem): sap.ui.unified.Shell;

        /**
         * Destroys all the curtainContent in the aggregation <code>curtainContent</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyCurtainContent(): sap.ui.unified.Shell;

        /**
         * Destroys all the curtainPaneContent in the aggregation <code>curtainPaneContent</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyCurtainPaneContent(): sap.ui.unified.Shell;

        /**
         * Destroys all the headEndItems in the aggregation <code>headEndItems</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyHeadEndItems(): sap.ui.unified.Shell;

        /**
         * Destroys the header in the aggregation named <code>header</code>, but only if a custom header is
         * set.The default header can not be destroyed.
         * @returns <code>this</code> to allow method chaining
        */
        destroyHeader(): sap.ui.unified.Shell;

        /**
         * Destroys all the headItems in the aggregation <code>headItems</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyHeadItems(): sap.ui.unified.Shell;

        /**
         * Destroys the search in the aggregation <code>search</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroySearch(): sap.ui.unified.Shell;

        /**
         * Destroys the user in the aggregation <code>user</code>.
         * @since 1.22.0
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyUser(): sap.ui.unified.Shell;


        /**
         * Gets content of aggregation <code>curtainContent</code>.The content to appear in the curtain area.
        */
        getCurtainContent(): sap.ui.core.Control[];

        /**
         * Gets content of aggregation <code>curtainPaneContent</code>.The content to appear in the pane area
         * of the curtain.
        */
        getCurtainPaneContent(): sap.ui.core.Control[];

        /**
         * Gets content of aggregation <code>headEndItems</code>.The buttons shown in the end (right in
         * left-to-right case) of the Shell header. Currently max. 3 visible buttons are supported (when user
         * is set only 1). If a custom header is set this aggregation has no effect.
        */
        getHeadEndItems(): sap.ui.unified.ShellHeadItem[];

        /**
         * Gets content of aggregation <code>headItems</code>.The buttons shown in the begin (left in
         * left-to-right case) of the Shell header. Currently max. 3 visible buttons are supported. If a custom
         * header is set this aggregation has no effect.
        */
        getHeadItems(): sap.ui.unified.ShellHeadItem[];

        /**
         * Gets current value of property <code>icon</code>.The application icon. If a custom header is set
         * this property has no effect.
         * @returns Value of property <code>icon</code>
        */
        getIcon(): any;

        /**
         * Returns a metadata object for class sap.ui.unified.Shell.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets content of aggregation <code>search</code>.Experimental (This aggregation might change in
         * future!): The search control which should be displayed in the shell header. If a custom header is
         * set this aggregation has no effect.
        */
        getSearch(): sap.ui.core.Control;

        /**
         * Gets current value of property <code>searchVisible</code>.If set to false, the search area
         * (aggregation 'search') is hidden. If a custom header is set this property has no effect.Default
         * value is <code>true</code>.
         * @since 1.18
         * @returns Value of property <code>searchVisible</code>
        */
        getSearchVisible(): boolean;

        /**
         * Gets current value of property <code>showCurtain</code>.Shows / Hides the curtain.
         * @returns Value of property <code>showCurtain</code>
        */
        getShowCurtain(): boolean;

        /**
         * Gets current value of property <code>showCurtainPane</code>.Shows / Hides the side pane on the
         * curtain.
         * @returns Value of property <code>showCurtainPane</code>
        */
        getShowCurtainPane(): boolean;

        /**
         * Gets content of aggregation <code>user</code>.The user item which is rendered in the shell header
         * beside the items. If a custom header is set this aggregation has no effect.
         * @since 1.22.0
        */
        getUser(): sap.ui.unified.ShellHeadUserItem;

        /**
         * Checks for the provided <code>sap.ui.core.Control</code> in the aggregation
         * <code>curtainContent</code>.and returns its index if found or -1 otherwise.
         * @param oCurtainContent The curtainContent whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfCurtainContent(oCurtainContent: sap.ui.core.Control): number;

        /**
         * Checks for the provided <code>sap.ui.core.Control</code> in the aggregation
         * <code>curtainPaneContent</code>.and returns its index if found or -1 otherwise.
         * @param oCurtainPaneContent The curtainPaneContent whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfCurtainPaneContent(oCurtainPaneContent: sap.ui.core.Control): number;

        /**
         * Checks for the provided <code>sap.ui.unified.ShellHeadItem</code> in the aggregation
         * <code>headEndItems</code>.and returns its index if found or -1 otherwise.
         * @param oHeadEndItem The headEndItem whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfHeadEndItem(oHeadEndItem: sap.ui.unified.ShellHeadItem): number;

        /**
         * Checks for the provided <code>sap.ui.unified.ShellHeadItem</code> in the aggregation
         * <code>headItems</code>.and returns its index if found or -1 otherwise.
         * @param oHeadItem The headItem whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfHeadItem(oHeadItem: sap.ui.unified.ShellHeadItem): number;

        /**
         * Inserts a curtainContent into the aggregation <code>curtainContent</code>.
         * @param oCurtainContent the curtainContent to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the curtainContent should be inserted at; for          
         *   a negative value of <code>iIndex</code>, the curtainContent is inserted at position 0; for a value
         *             greater than the current size of the aggregation, the curtainContent is inserted at     
         *        the last position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertCurtainContent(oCurtainContent: sap.ui.core.Control, iIndex: number): sap.ui.unified.Shell;

        /**
         * Inserts a curtainPaneContent into the aggregation <code>curtainPaneContent</code>.
         * @param oCurtainPaneContent the curtainPaneContent to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the curtainPaneContent should be inserted at; for      
         *       a negative value of <code>iIndex</code>, the curtainPaneContent is inserted at position 0; for
         * a value             greater than the current size of the aggregation, the curtainPaneContent is
         * inserted at             the last position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertCurtainPaneContent(oCurtainPaneContent: sap.ui.core.Control, iIndex: number): sap.ui.unified.Shell;

        /**
         * Inserts a headEndItem into the aggregation <code>headEndItems</code>.
         * @param oHeadEndItem the headEndItem to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the headEndItem should be inserted at; for            
         * a negative value of <code>iIndex</code>, the headEndItem is inserted at position 0; for a value     
         *        greater than the current size of the aggregation, the headEndItem is inserted at            
         * the last position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertHeadEndItem(oHeadEndItem: sap.ui.unified.ShellHeadItem, iIndex: number): sap.ui.unified.Shell;

        /**
         * Inserts a headItem into the aggregation <code>headItems</code>.
         * @param oHeadItem the headItem to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the headItem should be inserted at; for             a
         * negative value of <code>iIndex</code>, the headItem is inserted at position 0; for a value          
         *   greater than the current size of the aggregation, the headItem is inserted at             the last
         * position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertHeadItem(oHeadItem: sap.ui.unified.ShellHeadItem, iIndex: number): sap.ui.unified.Shell;

        /**
         * Removes all the controls from the aggregation <code>curtainContent</code>.Additionally, it
         * unregisters them from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllCurtainContent(): sap.ui.core.Control[];

        /**
         * Removes all the controls from the aggregation <code>curtainPaneContent</code>.Additionally, it
         * unregisters them from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllCurtainPaneContent(): sap.ui.core.Control[];

        /**
         * Removes all the controls from the aggregation <code>headEndItems</code>.Additionally, it unregisters
         * them from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllHeadEndItems(): sap.ui.unified.ShellHeadItem[];

        /**
         * Removes all the controls from the aggregation <code>headItems</code>.Additionally, it unregisters
         * them from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllHeadItems(): sap.ui.unified.ShellHeadItem[];

        /**
         * Removes a curtainContent from the aggregation <code>curtainContent</code>.
         * @param vCurtainContent The curtainContent to remove or its index or id
         * @returns The removed curtainContent or <code>null</code>
        */
        removeCurtainContent(vCurtainContent: number | string | sap.ui.core.Control): sap.ui.core.Control;

        /**
         * Removes a curtainPaneContent from the aggregation <code>curtainPaneContent</code>.
         * @param vCurtainPaneContent The curtainPaneContent to remove or its index or id
         * @returns The removed curtainPaneContent or <code>null</code>
        */
        removeCurtainPaneContent(vCurtainPaneContent: number | string | sap.ui.core.Control): sap.ui.core.Control;

        /**
         * Removes a headEndItem from the aggregation <code>headEndItems</code>.
         * @param vHeadEndItem The headEndItem to remove or its index or id
         * @returns The removed headEndItem or <code>null</code>
        */
        removeHeadEndItem(vHeadEndItem: number | string | sap.ui.unified.ShellHeadItem): sap.ui.unified.ShellHeadItem;

        /**
         * Removes a headItem from the aggregation <code>headItems</code>.
         * @param vHeadItem The headItem to remove or its index or id
         * @returns The removed headItem or <code>null</code>
        */
        removeHeadItem(vHeadItem: number | string | sap.ui.unified.ShellHeadItem): sap.ui.unified.ShellHeadItem;

        /**
         * Setter for the aggregated <code>header</code>.
         * @param oHeader The Control which should be rendered within the Shell header or <code>null</code> to
         * render the default Shell header.
         * @returns <code>this</code> to allow method chaining
        */
        setHeader(oHeader: sap.ui.core.Control): sap.ui.unified.Shell;

        /**
         * Sets a new value for property <code>icon</code>.The application icon. If a custom header is set this
         * property has no effect.When called with a value of <code>null</code> or <code>undefined</code>, the
         * default value of the property will be restored.
         * @param sIcon New value for property <code>icon</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setIcon(sIcon: any): sap.ui.unified.Shell;

        /**
         * Sets the aggregated <code>search</code>.
         * @param oSearch The search to set
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setSearch(oSearch: sap.ui.core.Control): sap.ui.unified.Shell;

        /**
         * Sets a new value for property <code>searchVisible</code>.If set to false, the search area
         * (aggregation 'search') is hidden. If a custom header is set this property has no effect.When called
         * with a value of <code>null</code> or <code>undefined</code>, the default value of the property will
         * be restored.Default value is <code>true</code>.
         * @since 1.18
         * @param bSearchVisible New value for property <code>searchVisible</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setSearchVisible(bSearchVisible: boolean): sap.ui.unified.Shell;

        /**
         * Sets a new value for property <code>showCurtain</code>.Shows / Hides the curtain.When called with a
         * value of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.
         * @param bShowCurtain New value for property <code>showCurtain</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setShowCurtain(bShowCurtain: boolean): sap.ui.unified.Shell;

        /**
         * Sets a new value for property <code>showCurtainPane</code>.Shows / Hides the side pane on the
         * curtain.When called with a value of <code>null</code> or <code>undefined</code>, the default value
         * of the property will be restored.
         * @param bShowCurtainPane New value for property <code>showCurtainPane</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setShowCurtainPane(bShowCurtainPane: boolean): sap.ui.unified.Shell;

        /**
         * Sets the aggregated <code>user</code>.
         * @since 1.22.0
         * @param oUser The user to set
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setUser(oUser: sap.ui.unified.ShellHeadUserItem): sap.ui.unified.Shell;
      }
      /**
       * A text view which displays currency values and aligns them at the separator
       * @resource sap/ui/unified/Currency.js
      */
      export class Currency extends sap.ui.core.Control {


        /**
         * Constructor for a new Currency.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);




        /**
        */
        getAccessibilityInfo(): void;

        /**
         * Gets current value of property <code>currency</code>.Determines the displayed currency code (ISO
         * 4217).<b>Note: </b>If a * character is set instead of currency code,only the character itself will
         * be rendered, ignoring the <code>value</code> property.
         * @returns Value of property <code>currency</code>
        */
        getCurrency(): string;

        /**
         * Get symbol of the currency, if available
        */
        getCurrencySymbol(): string;

        /**
         * The formatted value
        */
        getFormattedValue(): string;

        /**
         * Gets current value of property <code>maxPrecision</code>.Defines the space that is available for the
         * precision of the various currencies.Default value is <code>3</code>.
         * @returns Value of property <code>maxPrecision</code>
        */
        getMaxPrecision(): number;

        /**
         * Returns a metadata object for class sap.ui.unified.Currency.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>useSymbol</code>.Show the currency symbol instead of the ISO
         * currency codeDefault value is <code>true</code>.
         * @returns Value of property <code>useSymbol</code>
        */
        getUseSymbol(): boolean;

        /**
         * Gets current value of property <code>value</code>.The currency valueDefault value is <code>0</code>.
         * @returns Value of property <code>value</code>
        */
        getValue(): number;

        /**
         * Initializes the control.
        */
        init(): void;
      }
      /**
       * Standard item to be used inside a menu. A menu item represents an action which can be selected by
       * the user in the menu orit can provide a submenu to organize the actions hierarchically.
       * @resource sap/ui/unified/MenuItem.js
      */
      export class MenuItem extends sap.ui.unified.MenuItemBase {


        /**
         * Constructor for a new MenuItem element.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId Id for the new control, generated automatically if no id is given
         * @param mSettings Initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);




        /**
         * Gets current value of property <code>icon</code>.Defines the icon of the {@link sap.ui.core.IconPool
         * sap.ui.core.IconPool} or an image which should be displayed on the item.Default value is
         * <code></code>.
         * @returns Value of property <code>icon</code>
        */
        getIcon(): any;

        /**
         * Returns a metadata object for class sap.ui.unified.MenuItem.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>text</code>.Defines the text which should be displayed on the
         * item.Default value is <code></code>.
         * @returns Value of property <code>text</code>
        */
        getText(): string;

        /**
         * Sets a new value for property <code>icon</code>.Defines the icon of the {@link sap.ui.core.IconPool
         * sap.ui.core.IconPool} or an image which should be displayed on the item.When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code></code>.
         * @param sIcon New value for property <code>icon</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setIcon(sIcon: any): sap.ui.unified.MenuItem;

        /**
         * Sets a new value for property <code>text</code>.Defines the text which should be displayed on the
         * item.When called with a value of <code>null</code> or <code>undefined</code>, the default value of
         * the property will be restored.Default value is <code></code>.
         * @param sText New value for property <code>text</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setText(sText: string): sap.ui.unified.MenuItem;
      }
      /**
       * Basic Calendar.This calendar is used for DatePickers
       * @resource sap/ui/unified/Calendar.js
      */
      export class Calendar extends sap.ui.core.Control {


        /**
         * Constructor for a new Calendar.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Adds some ariaLabelledBy into the association <code>ariaLabelledBy</code>.
         * @since 1.28.0
         * @param vAriaLabelledBy the ariaLabelledBy to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addAriaLabelledBy(vAriaLabelledBy: any | sap.ui.core.Control): typeof sap.ui.unified.Calendar;

        /**
         * Adds some disabledDate to the aggregation <code>disabledDates</code>.
         * @since 1.38.0
         * @param oDisabledDate the disabledDate to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addDisabledDate(oDisabledDate: sap.ui.unified.DateRange): typeof sap.ui.unified.Calendar;

        /**
         * Adds some selectedDate to the aggregation <code>selectedDates</code>.
         * @param oSelectedDate the selectedDate to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addSelectedDate(oSelectedDate: sap.ui.unified.DateRange): typeof sap.ui.unified.Calendar;

        /**
         * Adds some specialDate to the aggregation <code>specialDates</code>.
         * @since 1.24.0
         * @param oSpecialDate the specialDate to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addSpecialDate(oSpecialDate: sap.ui.unified.DateTypeRange): typeof sap.ui.unified.Calendar;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>cancel</code> event of this
         * <code>sap.ui.unified.Calendar</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.unified.Calendar</code> itself.Date selection was cancelled
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.unified.Calendar</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachCancel(oData: any, fnFunction: any, oListener?: any): typeof sap.ui.unified.Calendar;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>select</code> event of this
         * <code>sap.ui.unified.Calendar</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.unified.Calendar</code> itself.Date selection changed
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.unified.Calendar</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachSelect(oData: any, fnFunction: any, oListener?: any): typeof sap.ui.unified.Calendar;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>startDateChange</code> event of this
         * <code>sap.ui.unified.Calendar</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.unified.Calendar</code> itself.<code>startDate</code> was changed while
         * navigation in <code>Calendar</code>Use <code>getStartDate</code> function to determine the current
         * start date
         * @since 1.34.0
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.unified.Calendar</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachStartDateChange(oData: any, fnFunction: any, oListener?: any): typeof sap.ui.unified.Calendar;

        /**
         * Destroys all the disabledDates in the aggregation <code>disabledDates</code>.
         * @since 1.38.0
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyDisabledDates(): typeof sap.ui.unified.Calendar;

        /**
         * Destroys all the selectedDates in the aggregation <code>selectedDates</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroySelectedDates(): typeof sap.ui.unified.Calendar;

        /**
         * Destroys all the specialDates in the aggregation <code>specialDates</code>.
         * @since 1.24.0
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroySpecialDates(): typeof sap.ui.unified.Calendar;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>cancel</code> event of this
         * <code>sap.ui.unified.Calendar</code>.The passed function and listener object must match the ones
         * used for event registration.
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachCancel(fnFunction: any, oListener: any): typeof sap.ui.unified.Calendar;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>select</code> event of this
         * <code>sap.ui.unified.Calendar</code>.The passed function and listener object must match the ones
         * used for event registration.
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachSelect(fnFunction: any, oListener: any): typeof sap.ui.unified.Calendar;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>startDateChange</code> event of this
         * <code>sap.ui.unified.Calendar</code>.The passed function and listener object must match the ones
         * used for event registration.
         * @since 1.34.0
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachStartDateChange(fnFunction: any, oListener: any): typeof sap.ui.unified.Calendar;

        /**
         * Displays a date in the calendar but don't set the focus.
         * @since 1.28.0
         * @param oDate JavaScript date object for focused date.
         * @returns <code>this</code> to allow method chaining
        */
        displayDate(oDate: any): typeof sap.ui.unified.Calendar;


        /**
         * Fires event <code>cancel</code> to attached listeners.
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireCancel(mArguments: any): typeof sap.ui.unified.Calendar;

        /**
         * Fires event <code>select</code> to attached listeners.
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireSelect(mArguments: any): typeof sap.ui.unified.Calendar;

        /**
         * Fires event <code>startDateChange</code> to attached listeners.
         * @since 1.34.0
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireStartDateChange(mArguments: any): typeof sap.ui.unified.Calendar;

        /**
         * Sets the focused date of the calendar.
         * @param oDate JavaScript date object for focused date.
         * @returns <code>this</code> to allow method chaining
        */
        focusDate(oDate: any): typeof sap.ui.unified.Calendar;

        /**
         * Returns array of IDs of the elements which are the current targets of the association
         * <code>ariaLabelledBy</code>.
         * @since 1.28.0
        */
        getAriaLabelledBy(): any[];

        /**
         * Gets content of aggregation <code>disabledDates</code>.Date Ranges for disabled dates
         * @since 1.38.0
        */
        getDisabledDates(): sap.ui.unified.DateRange[];

        /**
         * Gets current value of property <code>firstDayOfWeek</code>.If set, the first day of the displayed
         * week is this day. Valid values are 0 to 6.If not a valid value is set, the default of the used
         * locale is used.Default value is <code>-1</code>.
         * @since 1.28.9
         * @returns Value of property <code>firstDayOfWeek</code>
        */
        getFirstDayOfWeek(): number;

        /**
         * Gets current value of property <code>intervalSelection</code>.If set, interval selection is
         * allowedDefault value is <code>false</code>.
         * @returns Value of property <code>intervalSelection</code>
        */
        getIntervalSelection(): boolean;

        /**
         * ID of the element which is the current target of the association <code>legend</code>, or
         * <code>null</code>.
         * @since 1.38.5
        */
        getLegend(): any;

        /**
         * Gets current value of property <code>maxDate</code>.Maximum date that can be shown and selected in
         * the Calendar. This must be a JavaScript date object.<b>Note:</b> if the date is inside of a month
         * the complete month is displayed,but dates outside the valid range can not be selected.<b>Note:</b>
         * If the <code>maxDate</code> is set to be before the <code>minDate</code>,the <code>minDate</code> is
         * set to the begin of the month of the <code>maxDate</code>.
         * @since 1.38.0
         * @returns Value of property <code>maxDate</code>
        */
        getMaxDate(): any;

        /**
         * Returns a metadata object for class sap.ui.unified.Calendar.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>minDate</code>.Minimum date that can be shown and selected in
         * the Calendar. This must be a JavaScript date object.<b>Note:</b> if the date is inside of a month
         * the complete month is displayed,but dates outside the valid range can not be selected.<b>Note:</b>
         * If the <code>minDate</code> is set to be after the <code>maxDate</code>,the <code>maxDate</code> is
         * set to the end of the month of the <code>minDate</code>.
         * @since 1.38.0
         * @returns Value of property <code>minDate</code>
        */
        getMinDate(): any;

        /**
         * Gets current value of property <code>months</code>.number of months displayedon phones always only
         * one month is displayedDefault value is <code>1</code>.
         * @since 1.28.0
         * @returns Value of property <code>months</code>
        */
        getMonths(): number;

        /**
         * Gets current value of property <code>nonWorkingDays</code>.If set, the provided weekdays are
         * displayed as non-working days.Valid values inside the array are 0 to 6.If not set, the weekend
         * defined in the locale settings is displayed as non-working days.
         * @since 1.28.9
         * @returns Value of property <code>nonWorkingDays</code>
        */
        getNonWorkingDays(): number;

        /**
         * Gets current value of property <code>primaryCalendarType</code>.If set, the calendar type is used
         * for display.If not set, the calendar type of the global configuration is used.
         * @since 1.34.0
         * @returns Value of property <code>primaryCalendarType</code>
        */
        getPrimaryCalendarType(): sap.ui.core.CalendarType;

        /**
         * Gets current value of property <code>secondaryCalendarType</code>.If set, the days are also
         * displayed in this calendar typeIf not set, the dates are only displayed in the primary calendar type
         * @since 1.34.0
         * @returns Value of property <code>secondaryCalendarType</code>
        */
        getSecondaryCalendarType(): sap.ui.core.CalendarType;

        /**
         * Gets content of aggregation <code>selectedDates</code>.Date Ranges for selected dates of the
         * DatePicker
        */
        getSelectedDates(): sap.ui.unified.DateRange[];

        /**
         * Gets current value of property <code>singleSelection</code>.If set, only a single date or interval,
         * if intervalSelection is enabled, can be selectedDefault value is <code>true</code>.
         * @returns Value of property <code>singleSelection</code>
        */
        getSingleSelection(): boolean;

        /**
         * Gets content of aggregation <code>specialDates</code>.Date Range with type to visualize special days
         * in the Calendar.If one day is assigned to more than one Type, only the first one will be used.
         * @since 1.24.0
        */
        getSpecialDates(): sap.ui.unified.DateTypeRange[];

        /**
         * Returns the first day of the displayed month.There might be some days of the previous month shown,
         * but they can not be focused.
         * @since 1.34.1
         * @returns JavaScript date object for start date.
        */
        getStartDate(): any;

        /**
         * Gets current value of property <code>width</code>.Width of Calendar<b>Note:</b> There is a theme
         * depending minimum width, so the calendar can not be set smaller.
         * @since 1.38.0
         * @returns Value of property <code>width</code>
        */
        getWidth(): any;

        /**
         * Checks for the provided <code>sap.ui.unified.DateRange</code> in the aggregation
         * <code>disabledDates</code>.and returns its index if found or -1 otherwise.
         * @since 1.38.0
         * @param oDisabledDate The disabledDate whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfDisabledDate(oDisabledDate: sap.ui.unified.DateRange): number;

        /**
         * Checks for the provided <code>sap.ui.unified.DateRange</code> in the aggregation
         * <code>selectedDates</code>.and returns its index if found or -1 otherwise.
         * @param oSelectedDate The selectedDate whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfSelectedDate(oSelectedDate: sap.ui.unified.DateRange): number;

        /**
         * Checks for the provided <code>sap.ui.unified.DateTypeRange</code> in the aggregation
         * <code>specialDates</code>.and returns its index if found or -1 otherwise.
         * @since 1.24.0
         * @param oSpecialDate The specialDate whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfSpecialDate(oSpecialDate: sap.ui.unified.DateTypeRange): number;

        /**
         * Inserts a disabledDate into the aggregation <code>disabledDates</code>.
         * @since 1.38.0
         * @param oDisabledDate the disabledDate to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the disabledDate should be inserted at; for            
         * a negative value of <code>iIndex</code>, the disabledDate is inserted at position 0; for a value    
         *         greater than the current size of the aggregation, the disabledDate is inserted at           
         *  the last position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertDisabledDate(oDisabledDate: sap.ui.unified.DateRange, iIndex: number): typeof sap.ui.unified.Calendar;

        /**
         * Inserts a selectedDate into the aggregation <code>selectedDates</code>.
         * @param oSelectedDate the selectedDate to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the selectedDate should be inserted at; for            
         * a negative value of <code>iIndex</code>, the selectedDate is inserted at position 0; for a value    
         *         greater than the current size of the aggregation, the selectedDate is inserted at           
         *  the last position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertSelectedDate(oSelectedDate: sap.ui.unified.DateRange, iIndex: number): typeof sap.ui.unified.Calendar;

        /**
         * Inserts a specialDate into the aggregation <code>specialDates</code>.
         * @since 1.24.0
         * @param oSpecialDate the specialDate to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the specialDate should be inserted at; for            
         * a negative value of <code>iIndex</code>, the specialDate is inserted at position 0; for a value     
         *        greater than the current size of the aggregation, the specialDate is inserted at            
         * the last position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertSpecialDate(oSpecialDate: sap.ui.unified.DateTypeRange, iIndex: number): typeof sap.ui.unified.Calendar;

        /**
         * Removes all the controls in the association named <code>ariaLabelledBy</code>.
         * @since 1.28.0
         * @returns An array of the removed elements (might be empty)
        */
        removeAllAriaLabelledBy(): any[];

        /**
         * Removes all the controls from the aggregation <code>disabledDates</code>.Additionally, it
         * unregisters them from the hosting UIArea.
         * @since 1.38.0
         * @returns An array of the removed elements (might be empty)
        */
        removeAllDisabledDates(): sap.ui.unified.DateRange[];

        /**
         * Removes all the controls from the aggregation <code>selectedDates</code>.Additionally, it
         * unregisters them from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllSelectedDates(): sap.ui.unified.DateRange[];

        /**
         * Removes all the controls from the aggregation <code>specialDates</code>.Additionally, it unregisters
         * them from the hosting UIArea.
         * @since 1.24.0
         * @returns An array of the removed elements (might be empty)
        */
        removeAllSpecialDates(): sap.ui.unified.DateTypeRange[];

        /**
         * Removes an ariaLabelledBy from the association named <code>ariaLabelledBy</code>.
         * @since 1.28.0
         * @param vAriaLabelledBy The ariaLabelledBy to be removed or its index or ID
         * @returns The removed ariaLabelledBy or <code>null</code>
        */
        removeAriaLabelledBy(vAriaLabelledBy: number | any | sap.ui.core.Control): any;

        /**
         * Removes a disabledDate from the aggregation <code>disabledDates</code>.
         * @since 1.38.0
         * @param vDisabledDate The disabledDate to remove or its index or id
         * @returns The removed disabledDate or <code>null</code>
        */
        removeDisabledDate(vDisabledDate: number | string | sap.ui.unified.DateRange): sap.ui.unified.DateRange;

        /**
         * Removes a selectedDate from the aggregation <code>selectedDates</code>.
         * @param vSelectedDate The selectedDate to remove or its index or id
         * @returns The removed selectedDate or <code>null</code>
        */
        removeSelectedDate(vSelectedDate: number | string | sap.ui.unified.DateRange): sap.ui.unified.DateRange;

        /**
         * Removes a specialDate from the aggregation <code>specialDates</code>.
         * @since 1.24.0
         * @param vSpecialDate The specialDate to remove or its index or id
         * @returns The removed specialDate or <code>null</code>
        */
        removeSpecialDate(vSpecialDate: number | string | sap.ui.unified.DateTypeRange): sap.ui.unified.DateTypeRange;

        /**
         * Sets a new value for property <code>firstDayOfWeek</code>.If set, the first day of the displayed
         * week is this day. Valid values are 0 to 6.If not a valid value is set, the default of the used
         * locale is used.When called with a value of <code>null</code> or <code>undefined</code>, the default
         * value of the property will be restored.Default value is <code>-1</code>.
         * @since 1.28.9
         * @param iFirstDayOfWeek New value for property <code>firstDayOfWeek</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setFirstDayOfWeek(iFirstDayOfWeek: number): void;

        /**
         * Sets a new value for property <code>intervalSelection</code>.If set, interval selection is
         * allowedWhen called with a value of <code>null</code> or <code>undefined</code>, the default value of
         * the property will be restored.Default value is <code>false</code>.
         * @param bIntervalSelection New value for property <code>intervalSelection</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setIntervalSelection(bIntervalSelection: boolean): typeof sap.ui.unified.Calendar;

        /**
         * Sets the associated <code>legend</code>.
         * @since 1.38.5
         * @param oLegend ID of an element which becomes the new target of this legend association;
         * alternatively, an element instance may be given
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setLegend(oLegend: any | sap.ui.unified.CalendarLegend): typeof sap.ui.unified.Calendar;

        /**
         * Sets a new value for property <code>maxDate</code>.Maximum date that can be shown and selected in
         * the Calendar. This must be a JavaScript date object.<b>Note:</b> if the date is inside of a month
         * the complete month is displayed,but dates outside the valid range can not be selected.<b>Note:</b>
         * If the <code>maxDate</code> is set to be before the <code>minDate</code>,the <code>minDate</code> is
         * set to the begin of the month of the <code>maxDate</code>.When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
         * @since 1.38.0
         * @param oMaxDate New value for property <code>maxDate</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setMaxDate(oMaxDate: any): typeof sap.ui.unified.Calendar;

        /**
         * Sets a new value for property <code>minDate</code>.Minimum date that can be shown and selected in
         * the Calendar. This must be a JavaScript date object.<b>Note:</b> if the date is inside of a month
         * the complete month is displayed,but dates outside the valid range can not be selected.<b>Note:</b>
         * If the <code>minDate</code> is set to be after the <code>maxDate</code>,the <code>maxDate</code> is
         * set to the end of the month of the <code>minDate</code>.When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
         * @since 1.38.0
         * @param oMinDate New value for property <code>minDate</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setMinDate(oMinDate: any): typeof sap.ui.unified.Calendar;

        /**
         * Sets a new value for property <code>months</code>.number of months displayedon phones always only
         * one month is displayedWhen called with a value of <code>null</code> or <code>undefined</code>, the
         * default value of the property will be restored.Default value is <code>1</code>.
         * @since 1.28.0
         * @param iMonths New value for property <code>months</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setMonths(iMonths: number): void;

        /**
         * Sets a new value for property <code>nonWorkingDays</code>.If set, the provided weekdays are
         * displayed as non-working days.Valid values inside the array are 0 to 6.If not set, the weekend
         * defined in the locale settings is displayed as non-working days.When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
         * @since 1.28.9
         * @param sNonWorkingDays New value for property <code>nonWorkingDays</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setNonWorkingDays(sNonWorkingDays: number): typeof sap.ui.unified.Calendar;

        /**
         * Sets a new value for property <code>primaryCalendarType</code>.If set, the calendar type is used for
         * display.If not set, the calendar type of the global configuration is used.When called with a value
         * of <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
         * @since 1.34.0
         * @param sPrimaryCalendarType New value for property <code>primaryCalendarType</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setPrimaryCalendarType(sPrimaryCalendarType: sap.ui.core.CalendarType): typeof sap.ui.unified.Calendar;

        /**
         * Sets a new value for property <code>secondaryCalendarType</code>.If set, the days are also displayed
         * in this calendar typeIf not set, the dates are only displayed in the primary calendar typeWhen
         * called with a value of <code>null</code> or <code>undefined</code>, the default value of the
         * property will be restored.
         * @since 1.34.0
         * @param sSecondaryCalendarType New value for property <code>secondaryCalendarType</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setSecondaryCalendarType(sSecondaryCalendarType: sap.ui.core.CalendarType): typeof sap.ui.unified.Calendar;

        /**
         * Sets a new value for property <code>singleSelection</code>.If set, only a single date or interval,
         * if intervalSelection is enabled, can be selectedWhen called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.Default value is
         * <code>true</code>.
         * @param bSingleSelection New value for property <code>singleSelection</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setSingleSelection(bSingleSelection: boolean): typeof sap.ui.unified.Calendar;

        /**
         * Sets a new value for property <code>width</code>.Width of Calendar<b>Note:</b> There is a theme
         * depending minimum width, so the calendar can not be set smaller.When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
         * @since 1.38.0
         * @param sWidth New value for property <code>width</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setWidth(sWidth: any): typeof sap.ui.unified.Calendar;
      }
      /**
       * Date range for use in DatePicker
       * @resource sap/ui/unified/DateRange.js
      */
      export class DateRange extends sap.ui.core.Element {


        /**
         * Constructor for a new DateRange.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);




        /**
         * Gets current value of property <code>endDate</code>.Start date for a date range. If empty only a
         * single date is presented by this DateRange element. This must be a JavaScript date object.
         * @returns Value of property <code>endDate</code>
        */
        getEndDate(): any;

        /**
         * Returns a metadata object for class sap.ui.unified.DateRange.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>startDate</code>.Start date for a date range. This must be a
         * JavaScript date object.
         * @returns Value of property <code>startDate</code>
        */
        getStartDate(): any;

        /**
         * Sets a new value for property <code>endDate</code>.Start date for a date range. If empty only a
         * single date is presented by this DateRange element. This must be a JavaScript date object.When
         * called with a value of <code>null</code> or <code>undefined</code>, the default value of the
         * property will be restored.
         * @param oEndDate New value for property <code>endDate</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setEndDate(oEndDate: any): sap.ui.unified.DateRange;

        /**
         * Sets a new value for property <code>startDate</code>.Start date for a date range. This must be a
         * JavaScript date object.When called with a value of <code>null</code> or <code>undefined</code>, the
         * default value of the property will be restored.
         * @param oStartDate New value for property <code>startDate</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setStartDate(oStartDate: any): sap.ui.unified.DateRange;
      }
      /**
       * A calendar row with an header and appointments. The Appointments will be placed in the defined
       * interval.
       * @resource sap/ui/unified/CalendarRow.js
      */
      export class CalendarRow extends sap.ui.core.Control {


        /**
         * Constructor for a new <code>CalendarRow</code>.Accepts an object literal <code>mSettings</code> that
         * defines initialproperty values, aggregated and associated objects as well as event handlers.See
         * {@link sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the
         * settings object.
         * @param sId ID for the new control, generated automatically if no ID is given
         * @param mSettings Initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Adds some appointment to the aggregation <code>appointments</code>.
         * @param oAppointment the appointment to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addAppointment(oAppointment: sap.ui.unified.CalendarAppointment): sap.ui.unified.CalendarRow;

        /**
         * Adds some ariaLabelledBy into the association <code>ariaLabelledBy</code>.
         * @param vAriaLabelledBy the ariaLabelledBy to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addAriaLabelledBy(vAriaLabelledBy: any | sap.ui.core.Control): sap.ui.unified.CalendarRow;

        /**
         * Adds some intervalHeader to the aggregation <code>intervalHeaders</code>.
         * @param oIntervalHeader the intervalHeader to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addIntervalHeader(oIntervalHeader: sap.ui.unified.CalendarAppointment): sap.ui.unified.CalendarRow;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>intervalSelect</code> event of this
         * <code>sap.ui.unified.CalendarRow</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.unified.CalendarRow</code> itself.Fired if an interval was selected
         * @since 1.38.0
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.unified.CalendarRow</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachIntervalSelect(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.CalendarRow;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>leaveRow</code> event of this
         * <code>sap.ui.unified.CalendarRow</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.unified.CalendarRow</code> itself.The <code>CalendarRow</code> should be left
         * while navigating. (Arrow up or arrow down.)The caller should determine the next control to be
         * focused
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.unified.CalendarRow</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachLeaveRow(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.CalendarRow;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>select</code> event of this
         * <code>sap.ui.unified.CalendarRow</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.unified.CalendarRow</code> itself.Fired if an appointment was selected
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.unified.CalendarRow</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachSelect(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.CalendarRow;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>startDateChange</code> event of this
         * <code>sap.ui.unified.CalendarRow</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.unified.CalendarRow</code> itself.<code>startDate</code> was changed while
         * navigating in <code>CalendarRow</code>
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.unified.CalendarRow</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachStartDateChange(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.CalendarRow;

        /**
         * Destroys all the appointments in the aggregation <code>appointments</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyAppointments(): sap.ui.unified.CalendarRow;

        /**
         * Destroys all the intervalHeaders in the aggregation <code>intervalHeaders</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyIntervalHeaders(): sap.ui.unified.CalendarRow;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>intervalSelect</code> event of this
         * <code>sap.ui.unified.CalendarRow</code>.The passed function and listener object must match the ones
         * used for event registration.
         * @since 1.38.0
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachIntervalSelect(fnFunction: any, oListener: any): sap.ui.unified.CalendarRow;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>leaveRow</code> event of this
         * <code>sap.ui.unified.CalendarRow</code>.The passed function and listener object must match the ones
         * used for event registration.
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachLeaveRow(fnFunction: any, oListener: any): sap.ui.unified.CalendarRow;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>select</code> event of this
         * <code>sap.ui.unified.CalendarRow</code>.The passed function and listener object must match the ones
         * used for event registration.
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachSelect(fnFunction: any, oListener: any): sap.ui.unified.CalendarRow;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>startDateChange</code> event of this
         * <code>sap.ui.unified.CalendarRow</code>.The passed function and listener object must match the ones
         * used for event registration.
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachStartDateChange(fnFunction: any, oListener: any): sap.ui.unified.CalendarRow;


        /**
         * Fires event <code>intervalSelect</code> to attached listeners.Expects the following event
         * parameters:<ul><li><code>startDate</code> of type <code>object</code>Interval start date as
         * JavaScript date object</li><li><code>endDate</code> of type <code>object</code>Interval end date as
         * JavaScript date object</li><li><code>subInterval</code> of type <code>boolean</code>If set, the
         * selected interval is a subinterval</li></ul>
         * @since 1.38.0
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireIntervalSelect(mArguments: any): sap.ui.unified.CalendarRow;

        /**
         * Fires event <code>leaveRow</code> to attached listeners.Expects the following event
         * parameters:<ul><li><code>type</code> of type <code>string</code>The type of the event that triggers
         * this <code>leaveRow</code></li></ul>
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireLeaveRow(mArguments: any): sap.ui.unified.CalendarRow;

        /**
         * Fires event <code>select</code> to attached listeners.Expects the following event
         * parameters:<ul><li><code>appointment</code> of type
         * <code>sap.ui.unified.CalendarAppointment</code>selected
         * appointment</li><li><code>appointments</code> of type
         * <code>sap.ui.unified.CalendarAppointment[]</code>selected appointments in case a group appointment
         * is selected</li><li><code>multiSelect</code> of type <code>boolean</code>If set, the appointment was
         * selected by multiple selection (e.g. shift + mouse click).So more than the current appointment could
         * be selected.</li></ul>
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireSelect(mArguments: any): sap.ui.unified.CalendarRow;

        /**
         * Fires event <code>startDateChange</code> to attached listeners.
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireStartDateChange(mArguments: any): sap.ui.unified.CalendarRow;

        /**
         * Focus the given <code>CalendarAppointment</code> in the <code>CalendarRow</code>.
         * @param oAppointment Appointment to be focused.
         * @returns <code>this</code> to allow method chaining
        */
        focusAppointment(oAppointment: CalendarAppointment): sap.ui.unified.CalendarRow;

        /**
         * Focus the <code>CalendarAppointment</code> in the <code>CalendarRow</code> that is nearest tothe
         * given date.
         * @param oDate Javascript Date object.
         * @returns <code>this</code> to allow method chaining
        */
        focusNearestAppointment(oDate: any): sap.ui.unified.CalendarRow;

        /**
         * Gets content of aggregation <code>appointments</code>.Appointments to be displayed in the row.
         * Appointments outside the visible time frame are not rendered.<b>Note:</b> For performance reasons,
         * only appointments in the visible time range or nearby should be assigned.
        */
        getAppointments(): sap.ui.unified.CalendarAppointment[];

        /**
         * Gets current value of property <code>appointmentsReducedHeight</code>.If set the appointments
         * without text (only title) are rendered with a smaller height.<b>Note:</b> On phone devices this
         * property is ignored, appointments are always rendered in full heightto allow touching.Default value
         * is <code>false</code>.
         * @since 1.38.0
         * @returns Value of property <code>appointmentsReducedHeight</code>
        */
        getAppointmentsReducedHeight(): boolean;

        /**
         * Gets current value of property <code>appointmentsVisualization</code>.Defines the visualization of
         * the <code>CalendarAppoinment</code><b>Note:</b> The real visualization depends on the used
         * theme.Default value is <code>Standard</code>.
         * @since 1.40.0
         * @returns Value of property <code>appointmentsVisualization</code>
        */
        getAppointmentsVisualization(): sap.ui.unified.CalendarAppointmentVisualization;

        /**
         * Returns array of IDs of the elements which are the current targets of the association
         * <code>ariaLabelledBy</code>.
        */
        getAriaLabelledBy(): any[];

        /**
         * Gets current value of property <code>checkResize</code>.If set, the <code>CalendarRow</code> checks
         * for resize by itself.If a lot of <code>CalendarRow</code> controls are used in one container control
         * (like <code>PlanningCalendar</code>).the resize checks should be done only by this container
         * control. Then the container control shouldcall <code>handleResize</code> of the
         * <code>CalendarRow</code> if a resize happens.Default value is <code>true</code>.
         * @returns Value of property <code>checkResize</code>
        */
        getCheckResize(): boolean;

        /**
         * Returns the focused <code>CalendarAppointment</code> of the <code>CalendarRow</code>.The focus must
         * not really be on the <code>CalendarAppointment</code>, it have just tobe the one that has the focus
         * when the <code>CalendarRow</code> was focused last time.
         * @returns Focused Appointment
        */
        getFocusedAppointment(): sap.ui.unified.CalendarAppointment;

        /**
         * Gets current value of property <code>height</code>.Height of the row
         * @returns Value of property <code>height</code>
        */
        getHeight(): any;

        /**
         * Gets content of aggregation <code>intervalHeaders</code>.Appointments to be displayed in the top of
         * the intervals. The <code>intervalHeaders</code> are used to visualizepublic holidays and similar
         * things.Appointments outside the visible time frame are not rendered.The <code>intervalHeaders</code>
         * always fill whole intervals. If they are shorter than one interval, they are not
         * displayed.<b>Note:</b> For performance reasons, only appointments in the visible time range or
         * nearby should be assigned.
        */
        getIntervalHeaders(): sap.ui.unified.CalendarAppointment[];

        /**
         * Gets current value of property <code>intervals</code>.Number of displayed intervals. The size of the
         * intervals is defined with <code>intervalType</code>Default value is <code>12</code>.
         * @returns Value of property <code>intervals</code>
        */
        getIntervals(): number;

        /**
         * Gets current value of property <code>intervalType</code>.Type of the intervals of the row. The
         * default is one hour.Default value is <code>Hour</code>.
         * @returns Value of property <code>intervalType</code>
        */
        getIntervalType(): sap.ui.unified.CalendarIntervalType;

        /**
         * ID of the element which is the current target of the association <code>legend</code>, or
         * <code>null</code>.
         * @since 1.40.0
        */
        getLegend(): any;

        /**
         * Returns a metadata object for class sap.ui.unified.CalendarRow.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>nonWorkingDays</code>.If set, the provided weekdays are
         * displayed as non-working days.Valid values inside the array are 0 to 6. (Other values will just be
         * ignored.)If not set, the weekend defined in the locale settings is displayed as non-working
         * days.<b>Note:</b> The non working days are only visualized if <code>intervalType</code> is set to
         * day.
         * @returns Value of property <code>nonWorkingDays</code>
        */
        getNonWorkingDays(): number;

        /**
         * Gets current value of property <code>nonWorkingHours</code>.If set, the provided hours are displayed
         * as non-working hours.Valid values inside the array are 0 to 23. (Other values will just be
         * ignored.)<b>Note:</b> The non working hours are only visualized if <code>intervalType</code> is set
         * to hour.
         * @returns Value of property <code>nonWorkingHours</code>
        */
        getNonWorkingHours(): number;

        /**
         * Gets current value of property <code>showEmptyIntervalHeaders</code>.If set, interval headers are
         * shown even if no <code>intervalHeaders</code> are assigned to the visible time frame.If not set, no
         * interval headers are shown if no <code>intervalHeaders</code> are assigned.<b>Note:</b> This
         * property is only used if <code>showIntervalHeaders</code> is set to true.Default value is
         * <code>true</code>.
         * @since 1.38.0
         * @returns Value of property <code>showEmptyIntervalHeaders</code>
        */
        getShowEmptyIntervalHeaders(): boolean;

        /**
         * Gets current value of property <code>showIntervalHeaders</code>.If set, interval headers are shown
         * like specified in <code>showEmptyIntervalHeaders</code>.If not set, no interval headers are shown
         * even if <code>intervalHeaders</code> are assigned.Default value is <code>true</code>.
         * @returns Value of property <code>showIntervalHeaders</code>
        */
        getShowIntervalHeaders(): boolean;

        /**
         * Gets current value of property <code>showSubIntervals</code>.If set, subintervals are shown.If the
         * interval type is <code>Hour</code>, quarter hours are shown.If the interval type is
         * <code>Day</code>, hours are shown.If the interval type is <code>Month</code>, days are shown.Default
         * value is <code>false</code>.
         * @returns Value of property <code>showSubIntervals</code>
        */
        getShowSubIntervals(): boolean;

        /**
         * Gets current value of property <code>startDate</code>.Start date, as JavaScript Date object, of the
         * row. As default, the current date is used.
         * @returns Value of property <code>startDate</code>
        */
        getStartDate(): any;

        /**
         * Gets current value of property <code>updateCurrentTime</code>.If set the <code>CalendarRow</code>
         * triggers a periodic update to visualize the current time.If a lot of <code>CalendarRow</code>
         * controls are used in one container control (like <code>PlanningCalendar</code>)the periodic update
         * should be triggered only by this container control. Then the container control shouldcall
         * <code>updateCurrentTimeVisualization</code> of the <code>CalendarRow</code> to update the
         * visualization.Default value is <code>true</code>.
         * @returns Value of property <code>updateCurrentTime</code>
        */
        getUpdateCurrentTime(): boolean;

        /**
         * Gets current value of property <code>width</code>.Width of the row
         * @returns Value of property <code>width</code>
        */
        getWidth(): any;

        /**
         * After a resize of the <code>CalendarRow</code>, some calculations for appointmentsizes are
         * needed.For this, each <code>CalendarRow</code> can trigger the resize check for it's own DOM.But if
         * multiple <code>CalendarRow</code>s are used in one container (e.g. <code>PlanningCalendar</code>),it
         * is better if the container triggers the resize check once an then calls this functionof each
         * <code>CalendarRow</code>.
         * @param oEvent The event object of the resize handler.
         * @returns <code>this</code> to allow method chaining
        */
        handleResize(oEvent: any): sap.ui.unified.CalendarRow;

        /**
         * Checks for the provided <code>sap.ui.unified.CalendarAppointment</code> in the aggregation
         * <code>appointments</code>.and returns its index if found or -1 otherwise.
         * @param oAppointment The appointment whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfAppointment(oAppointment: sap.ui.unified.CalendarAppointment): number;

        /**
         * Checks for the provided <code>sap.ui.unified.CalendarAppointment</code> in the aggregation
         * <code>intervalHeaders</code>.and returns its index if found or -1 otherwise.
         * @param oIntervalHeader The intervalHeader whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfIntervalHeader(oIntervalHeader: sap.ui.unified.CalendarAppointment): number;

        /**
         * Inserts a appointment into the aggregation <code>appointments</code>.
         * @param oAppointment the appointment to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the appointment should be inserted at; for            
         * a negative value of <code>iIndex</code>, the appointment is inserted at position 0; for a value     
         *        greater than the current size of the aggregation, the appointment is inserted at            
         * the last position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertAppointment(oAppointment: sap.ui.unified.CalendarAppointment, iIndex: number): sap.ui.unified.CalendarRow;

        /**
         * Inserts a intervalHeader into the aggregation <code>intervalHeaders</code>.
         * @param oIntervalHeader the intervalHeader to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the intervalHeader should be inserted at; for          
         *   a negative value of <code>iIndex</code>, the intervalHeader is inserted at position 0; for a value
         *             greater than the current size of the aggregation, the intervalHeader is inserted at     
         *        the last position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertIntervalHeader(oIntervalHeader: sap.ui.unified.CalendarAppointment, iIndex: number): sap.ui.unified.CalendarRow;

        /**
         * Removes all the controls from the aggregation <code>appointments</code>.Additionally, it unregisters
         * them from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllAppointments(): sap.ui.unified.CalendarAppointment[];

        /**
         * Removes all the controls in the association named <code>ariaLabelledBy</code>.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllAriaLabelledBy(): any[];

        /**
         * Removes all the controls from the aggregation <code>intervalHeaders</code>.Additionally, it
         * unregisters them from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllIntervalHeaders(): sap.ui.unified.CalendarAppointment[];

        /**
         * Removes a appointment from the aggregation <code>appointments</code>.
         * @param vAppointment The appointment to remove or its index or id
         * @returns The removed appointment or <code>null</code>
        */
        removeAppointment(vAppointment: number | string | sap.ui.unified.CalendarAppointment): sap.ui.unified.CalendarAppointment;

        /**
         * Removes an ariaLabelledBy from the association named <code>ariaLabelledBy</code>.
         * @param vAriaLabelledBy The ariaLabelledBy to be removed or its index or ID
         * @returns The removed ariaLabelledBy or <code>null</code>
        */
        removeAriaLabelledBy(vAriaLabelledBy: number | any | sap.ui.core.Control): any;

        /**
         * Removes a intervalHeader from the aggregation <code>intervalHeaders</code>.
         * @param vIntervalHeader The intervalHeader to remove or its index or id
         * @returns The removed intervalHeader or <code>null</code>
        */
        removeIntervalHeader(vIntervalHeader: number | string | sap.ui.unified.CalendarAppointment): sap.ui.unified.CalendarAppointment;

        /**
         * Sets a new value for property <code>appointmentsReducedHeight</code>.If set the appointments without
         * text (only title) are rendered with a smaller height.<b>Note:</b> On phone devices this property is
         * ignored, appointments are always rendered in full heightto allow touching.When called with a value
         * of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>false</code>.
         * @since 1.38.0
         * @param bAppointmentsReducedHeight New value for property <code>appointmentsReducedHeight</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setAppointmentsReducedHeight(bAppointmentsReducedHeight: boolean): sap.ui.unified.CalendarRow;

        /**
         * Sets a new value for property <code>appointmentsVisualization</code>.Defines the visualization of
         * the <code>CalendarAppoinment</code><b>Note:</b> The real visualization depends on the used
         * theme.When called with a value of <code>null</code> or <code>undefined</code>, the default value of
         * the property will be restored.Default value is <code>Standard</code>.
         * @since 1.40.0
         * @param sAppointmentsVisualization New value for property <code>appointmentsVisualization</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setAppointmentsVisualization(sAppointmentsVisualization: sap.ui.unified.CalendarAppointmentVisualization): sap.ui.unified.CalendarRow;

        /**
         * Sets a new value for property <code>checkResize</code>.If set, the <code>CalendarRow</code> checks
         * for resize by itself.If a lot of <code>CalendarRow</code> controls are used in one container control
         * (like <code>PlanningCalendar</code>).the resize checks should be done only by this container
         * control. Then the container control shouldcall <code>handleResize</code> of the
         * <code>CalendarRow</code> if a resize happens.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.Default value is
         * <code>true</code>.
         * @param bCheckResize New value for property <code>checkResize</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setCheckResize(bCheckResize: boolean): sap.ui.unified.CalendarRow;

        /**
         * Sets a new value for property <code>height</code>.Height of the rowWhen called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
         * @param sHeight New value for property <code>height</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setHeight(sHeight: any): sap.ui.unified.CalendarRow;

        /**
         * Sets a new value for property <code>intervals</code>.Number of displayed intervals. The size of the
         * intervals is defined with <code>intervalType</code>When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.Default value is
         * <code>12</code>.
         * @param iIntervals New value for property <code>intervals</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setIntervals(iIntervals: number): sap.ui.unified.CalendarRow;

        /**
         * Sets a new value for property <code>intervalType</code>.Type of the intervals of the row. The
         * default is one hour.When called with a value of <code>null</code> or <code>undefined</code>, the
         * default value of the property will be restored.Default value is <code>Hour</code>.
         * @param sIntervalType New value for property <code>intervalType</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setIntervalType(sIntervalType: sap.ui.unified.CalendarIntervalType): sap.ui.unified.CalendarRow;

        /**
         * Sets the associated <code>legend</code>.
         * @since 1.40.0
         * @param oLegend ID of an element which becomes the new target of this legend association;
         * alternatively, an element instance may be given
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setLegend(oLegend: any | sap.ui.unified.CalendarLegend): sap.ui.unified.CalendarRow;

        /**
         * Sets a new value for property <code>nonWorkingDays</code>.If set, the provided weekdays are
         * displayed as non-working days.Valid values inside the array are 0 to 6. (Other values will just be
         * ignored.)If not set, the weekend defined in the locale settings is displayed as non-working
         * days.<b>Note:</b> The non working days are only visualized if <code>intervalType</code> is set to
         * day.When called with a value of <code>null</code> or <code>undefined</code>, the default value of
         * the property will be restored.
         * @param sNonWorkingDays New value for property <code>nonWorkingDays</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setNonWorkingDays(sNonWorkingDays: number): sap.ui.unified.CalendarRow;

        /**
         * Sets a new value for property <code>nonWorkingHours</code>.If set, the provided hours are displayed
         * as non-working hours.Valid values inside the array are 0 to 23. (Other values will just be
         * ignored.)<b>Note:</b> The non working hours are only visualized if <code>intervalType</code> is set
         * to hour.When called with a value of <code>null</code> or <code>undefined</code>, the default value
         * of the property will be restored.
         * @param sNonWorkingHours New value for property <code>nonWorkingHours</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setNonWorkingHours(sNonWorkingHours: number): sap.ui.unified.CalendarRow;

        /**
         * Sets a new value for property <code>showEmptyIntervalHeaders</code>.If set, interval headers are
         * shown even if no <code>intervalHeaders</code> are assigned to the visible time frame.If not set, no
         * interval headers are shown if no <code>intervalHeaders</code> are assigned.<b>Note:</b> This
         * property is only used if <code>showIntervalHeaders</code> is set to true.When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>true</code>.
         * @since 1.38.0
         * @param bShowEmptyIntervalHeaders New value for property <code>showEmptyIntervalHeaders</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setShowEmptyIntervalHeaders(bShowEmptyIntervalHeaders: boolean): sap.ui.unified.CalendarRow;

        /**
         * Sets a new value for property <code>showIntervalHeaders</code>.If set, interval headers are shown
         * like specified in <code>showEmptyIntervalHeaders</code>.If not set, no interval headers are shown
         * even if <code>intervalHeaders</code> are assigned.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.Default value is
         * <code>true</code>.
         * @param bShowIntervalHeaders New value for property <code>showIntervalHeaders</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setShowIntervalHeaders(bShowIntervalHeaders: boolean): sap.ui.unified.CalendarRow;

        /**
         * Sets a new value for property <code>showSubIntervals</code>.If set, subintervals are shown.If the
         * interval type is <code>Hour</code>, quarter hours are shown.If the interval type is
         * <code>Day</code>, hours are shown.If the interval type is <code>Month</code>, days are shown.When
         * called with a value of <code>null</code> or <code>undefined</code>, the default value of the
         * property will be restored.Default value is <code>false</code>.
         * @param bShowSubIntervals New value for property <code>showSubIntervals</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setShowSubIntervals(bShowSubIntervals: boolean): sap.ui.unified.CalendarRow;

        /**
         * Sets a new value for property <code>startDate</code>.Start date, as JavaScript Date object, of the
         * row. As default, the current date is used.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.
         * @param oStartDate New value for property <code>startDate</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setStartDate(oStartDate: any): sap.ui.unified.CalendarRow;

        /**
         * Sets a new value for property <code>updateCurrentTime</code>.If set the <code>CalendarRow</code>
         * triggers a periodic update to visualize the current time.If a lot of <code>CalendarRow</code>
         * controls are used in one container control (like <code>PlanningCalendar</code>)the periodic update
         * should be triggered only by this container control. Then the container control shouldcall
         * <code>updateCurrentTimeVisualization</code> of the <code>CalendarRow</code> to update the
         * visualization.When called with a value of <code>null</code> or <code>undefined</code>, the default
         * value of the property will be restored.Default value is <code>true</code>.
         * @param bUpdateCurrentTime New value for property <code>updateCurrentTime</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setUpdateCurrentTime(bUpdateCurrentTime: boolean): sap.ui.unified.CalendarRow;

        /**
         * Sets a new value for property <code>width</code>.Width of the rowWhen called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
         * @param sWidth New value for property <code>width</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setWidth(sWidth: any): sap.ui.unified.CalendarRow;

        /**
         * If the current time is in the visible output of the <code>CalendarRow</code>,the indicator for the
         * current time must be positioned.For this, each <code>CalendarRow</code> can trigger a timer.But if
         * multiple <code>CalendarRow</code>s are used in one container (e.G. <code>PlanningCalendar</code>),it
         * is better if the container triggers the interval once an then calls this functionof each
         * <code>CalendarRow</code>.
         * @returns <code>this</code> to allow method chaining
        */
        updateCurrentTimeVisualization(): sap.ui.unified.CalendarRow;
      }
      /**
       * The shell layout is the base for the shell control which is meant as root control (full-screen) of
       * an application.It was build as root control of the Fiori Launchpad application and provides the
       * basic capabilitiesfor this purpose. Do not use this control within applications which run inside the
       * Fiori Lauchpad anddo not use it for other scenarios than the root control usecase.
       * @resource sap/ui/unified/ShellLayout.js
      */
      export class ShellLayout extends sap.ui.core.Control {


        /**
         * Constructor for a new ShellLayout.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Adds some content to the aggregation <code>content</code>.
         * @param oContent the content to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addContent(oContent: sap.ui.core.Control): sap.ui.unified.ShellLayout;

        /**
         * Adds some paneContent to the aggregation <code>paneContent</code>.
         * @param oPaneContent the paneContent to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addPaneContent(oPaneContent: sap.ui.core.Control): sap.ui.unified.ShellLayout;

        /**
         * Destroys all the content in the aggregation <code>content</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyContent(): sap.ui.unified.ShellLayout;

        /**
         * Destroys the header in the aggregation <code>header</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyHeader(): sap.ui.unified.ShellLayout;

        /**
         * Destroys all the paneContent in the aggregation <code>paneContent</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyPaneContent(): sap.ui.unified.ShellLayout;


        /**
         * Gets content of aggregation <code>content</code>.The content to appear in the main canvas.
        */
        getContent(): sap.ui.core.Control[];

        /**
         * Gets content of aggregation <code>header</code>.The control to appear in the header area.
        */
        getHeader(): sap.ui.core.Control;

        /**
         * Gets current value of property <code>headerHiding</code>.Whether the header can be hidden (manually
         * or automatically). This feature is only available when touch events are supported.Default value is
         * <code>false</code>.
         * @returns Value of property <code>headerHiding</code>
        */
        getHeaderHiding(): boolean;

        /**
         * Gets current value of property <code>headerVisible</code>.If set to false, no header (and no items,
         * search, ...) is shown.Default value is <code>true</code>.
         * @returns Value of property <code>headerVisible</code>
        */
        getHeaderVisible(): boolean;

        /**
         * Returns a metadata object for class sap.ui.unified.ShellLayout.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets content of aggregation <code>paneContent</code>.The content to appear in the pane area.
        */
        getPaneContent(): sap.ui.core.Control[];

        /**
         * Gets current value of property <code>showPane</code>.Shows / Hides the side pane.Default value is
         * <code>false</code>.
         * @returns Value of property <code>showPane</code>
        */
        getShowPane(): boolean;

        /**
         * Checks for the provided <code>sap.ui.core.Control</code> in the aggregation <code>content</code>.and
         * returns its index if found or -1 otherwise.
         * @param oContent The content whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfContent(oContent: sap.ui.core.Control): number;

        /**
         * Checks for the provided <code>sap.ui.core.Control</code> in the aggregation
         * <code>paneContent</code>.and returns its index if found or -1 otherwise.
         * @param oPaneContent The paneContent whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfPaneContent(oPaneContent: sap.ui.core.Control): number;

        /**
         * Inserts a content into the aggregation <code>content</code>.
         * @param oContent the content to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the content should be inserted at; for             a
         * negative value of <code>iIndex</code>, the content is inserted at position 0; for a value           
         *  greater than the current size of the aggregation, the content is inserted at             the last
         * position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertContent(oContent: sap.ui.core.Control, iIndex: number): sap.ui.unified.ShellLayout;

        /**
         * Inserts a paneContent into the aggregation <code>paneContent</code>.
         * @param oPaneContent the paneContent to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the paneContent should be inserted at; for            
         * a negative value of <code>iIndex</code>, the paneContent is inserted at position 0; for a value     
         *        greater than the current size of the aggregation, the paneContent is inserted at            
         * the last position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertPaneContent(oPaneContent: sap.ui.core.Control, iIndex: number): sap.ui.unified.ShellLayout;

        /**
         * Removes all the controls from the aggregation <code>content</code>.Additionally, it unregisters them
         * from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllContent(): sap.ui.core.Control[];

        /**
         * Removes all the controls from the aggregation <code>paneContent</code>.Additionally, it unregisters
         * them from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllPaneContent(): sap.ui.core.Control[];

        /**
         * Removes a content from the aggregation <code>content</code>.
         * @param vContent The content to remove or its index or id
         * @returns The removed content or <code>null</code>
        */
        removeContent(vContent: number | string | sap.ui.core.Control): sap.ui.core.Control;

        /**
         * Removes a paneContent from the aggregation <code>paneContent</code>.
         * @param vPaneContent The paneContent to remove or its index or id
         * @returns The removed paneContent or <code>null</code>
        */
        removePaneContent(vPaneContent: number | string | sap.ui.core.Control): sap.ui.core.Control;

        /**
         * Sets the aggregated <code>header</code>.
         * @param oHeader The header to set
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setHeader(oHeader: sap.ui.core.Control): sap.ui.unified.ShellLayout;

        /**
         * Sets a new value for property <code>headerHiding</code>.Whether the header can be hidden (manually
         * or automatically). This feature is only available when touch events are supported.When called with a
         * value of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>false</code>.
         * @param bHeaderHiding New value for property <code>headerHiding</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setHeaderHiding(bHeaderHiding: boolean): sap.ui.unified.ShellLayout;

        /**
         * Sets a new value for property <code>headerVisible</code>.If set to false, no header (and no items,
         * search, ...) is shown.When called with a value of <code>null</code> or <code>undefined</code>, the
         * default value of the property will be restored.Default value is <code>true</code>.
         * @param bHeaderVisible New value for property <code>headerVisible</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setHeaderVisible(bHeaderVisible: boolean): sap.ui.unified.ShellLayout;

        /**
         * Sets a new value for property <code>showPane</code>.Shows / Hides the side pane.When called with a
         * value of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>false</code>.
         * @param bShowPane New value for property <code>showPane</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setShowPane(bShowPane: boolean): sap.ui.unified.ShellLayout;
      }
      /**
       * ShellOverlay to be opened in front of a sap.ui.unified.Shell
       * @resource sap/ui/unified/ShellOverlay.js
      */
      export class ShellOverlay extends sap.ui.core.Control {


        /**
         * Constructor for a new ShellOverlay.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Adds some ariaLabelledBy into the association <code>ariaLabelledBy</code>.
         * @param vAriaLabelledBy the ariaLabelledBy to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addAriaLabelledBy(vAriaLabelledBy: any | sap.ui.core.Control): sap.ui.unified.ShellOverlay;

        /**
         * Adds some content to the aggregation <code>content</code>.
         * @param oContent the content to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addContent(oContent: sap.ui.core.Control): sap.ui.unified.ShellOverlay;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>closed</code> event of this
         * <code>sap.ui.unified.ShellOverlay</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.unified.ShellOverlay</code> itself.Fired when the overlay was closed.
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.unified.ShellOverlay</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachClosed(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.ShellOverlay;

        /**
         * Closes the ShellOverlay.
        */
        close(): void;

        /**
         * Destroys all the content in the aggregation <code>content</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyContent(): sap.ui.unified.ShellOverlay;

        /**
         * Destroys the search in the aggregation <code>search</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroySearch(): sap.ui.unified.ShellOverlay;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>closed</code> event of this
         * <code>sap.ui.unified.ShellOverlay</code>.The passed function and listener object must match the ones
         * used for event registration.
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachClosed(fnFunction: any, oListener: any): sap.ui.unified.ShellOverlay;


        /**
         * Fires event <code>closed</code> to attached listeners.
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireClosed(mArguments: any): sap.ui.unified.ShellOverlay;

        /**
         * Returns array of IDs of the elements which are the current targets of the association
         * <code>ariaLabelledBy</code>.
        */
        getAriaLabelledBy(): any[];

        /**
         * Gets content of aggregation <code>content</code>.The content to appear in the overlay.
        */
        getContent(): sap.ui.core.Control[];

        /**
         * Returns a metadata object for class sap.ui.unified.ShellOverlay.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets content of aggregation <code>search</code>.Experimental (This aggregation might change in
         * future!): The search control which should be displayed in the overlay header.
        */
        getSearch(): sap.ui.core.Control;

        /**
         * ID of the element which is the current target of the association <code>shell</code>, or
         * <code>null</code>.
        */
        getShell(): any;

        /**
         * Checks for the provided <code>sap.ui.core.Control</code> in the aggregation <code>content</code>.and
         * returns its index if found or -1 otherwise.
         * @param oContent The content whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfContent(oContent: sap.ui.core.Control): number;

        /**
         * Inserts a content into the aggregation <code>content</code>.
         * @param oContent the content to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the content should be inserted at; for             a
         * negative value of <code>iIndex</code>, the content is inserted at position 0; for a value           
         *  greater than the current size of the aggregation, the content is inserted at             the last
         * position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertContent(oContent: sap.ui.core.Control, iIndex: number): sap.ui.unified.ShellOverlay;

        /**
         * Opens the ShellOverlay.
        */
        open(): void;

        /**
         * Removes all the controls in the association named <code>ariaLabelledBy</code>.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllAriaLabelledBy(): any[];

        /**
         * Removes all the controls from the aggregation <code>content</code>.Additionally, it unregisters them
         * from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllContent(): sap.ui.core.Control[];

        /**
         * Removes an ariaLabelledBy from the association named <code>ariaLabelledBy</code>.
         * @param vAriaLabelledBy The ariaLabelledBy to be removed or its index or ID
         * @returns The removed ariaLabelledBy or <code>null</code>
        */
        removeAriaLabelledBy(vAriaLabelledBy: number | any | sap.ui.core.Control): any;

        /**
         * Removes a content from the aggregation <code>content</code>.
         * @param vContent The content to remove or its index or id
         * @returns The removed content or <code>null</code>
        */
        removeContent(vContent: number | string | sap.ui.core.Control): sap.ui.core.Control;

        /**
         * Sets the aggregated <code>search</code>.
         * @param oSearch The search to set
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setSearch(oSearch: sap.ui.core.Control): sap.ui.unified.ShellOverlay;

        /**
         * Sets the associated <code>shell</code>.
         * @param oShell ID of an element which becomes the new target of this shell association;
         * alternatively, an element instance may be given
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setShell(oShell: any | sap.ui.unified.ShellLayout): sap.ui.unified.ShellOverlay;
      }
      /**
       * Abstract base class for menu item which provides common properties and events for all concrete item
       * implementations.
       * @resource sap/ui/unified/MenuItemBase.js
      */
      export abstract class MenuItemBase extends sap.ui.core.Element {


        /**
         * Abstract base class <code>MenuItemBase</code> for menu item elements. Please use concrete
         * subclasses.Accepts an object literal <code>mSettings</code> that defines initialproperty values,
         * aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId Id for the new control, generated automatically if no id is given
         * @param mSettings Initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Attaches event handler <code>fnFunction</code> to the <code>select</code> event of this
         * <code>sap.ui.unified.MenuItemBase</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.unified.MenuItemBase</code> itself.Fired when the item is selected by the
         * user.<b>Note:</b> The event is also available for items which have a submenu.In general,
         * applications must not handle event in this case because the user selection opens the sub menu.
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.unified.MenuItemBase</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachSelect(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.MenuItemBase;

        /**
         * Destroys the submenu in the aggregation <code>submenu</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroySubmenu(): sap.ui.unified.MenuItemBase;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>select</code> event of this
         * <code>sap.ui.unified.MenuItemBase</code>.The passed function and listener object must match the ones
         * used for event registration.
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachSelect(fnFunction: any, oListener: any): sap.ui.unified.MenuItemBase;


        /**
         * Fires event <code>select</code> to attached listeners.Expects the following event
         * parameters:<ul><li><code>item</code> of type <code>sap.ui.unified.MenuItemBase</code>The current
         * item</li></ul>
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireSelect(mArguments: any): sap.ui.unified.MenuItemBase;

        /**
         * Gets current value of property <code>enabled</code>.When an item is disabled the item can not be
         * selected by the user.The enabled property of the item has no effect when the menu of the item is
         * disabled ({@link sap.ui.unified.Menu#getEnabled Menu#getEnabled}).Default value is
         * <code>true</code>.
         * @returns Value of property <code>enabled</code>
        */
        getEnabled(): boolean;

        /**
         * Returns a metadata object for class sap.ui.unified.MenuItemBase.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>startsSection</code>.Defines whether a visual separator should
         * be rendered before the item.<b>Note:</b> If an item is invisible also the separator of this item is
         * not shown.Default value is <code>false</code>.
         * @returns Value of property <code>startsSection</code>
        */
        getStartsSection(): boolean;

        /**
         * Gets content of aggregation <code>submenu</code>.An optional submenu of the item which is opened
         * when the item is selected by the user.
        */
        getSubmenu(): sap.ui.unified.Menu;

        /**
         * Gets current value of property <code>visible</code>.Invisible items do not appear in the
         * menu.Default value is <code>true</code>.
         * @returns Value of property <code>visible</code>
        */
        getVisible(): boolean;

        /**
         * Changes the visual hover state of the menu item.Subclasses may override this function.
         * @param bHovered Specifies whether the item is currently hovered or not.
         * @param oMenu The menu to which this item belongs
        */
        hover(bHovered: boolean, oMenu: sap.ui.unified.Menu): void;

        /**
         * Informs the item that the item HTML is now applied to the DOM.Subclasses may override this function.
        */
        onAfterRendering(): void;

        /**
         * Event handler which is called whenever the submenu of the item is opened or closed.Subclasses may
         * override this function.
         * @param bOpened Specifies whether the submenu of the item is opened or closed
        */
        onSubmenuToggle(bOpened: boolean): void;

        /**
         * Produces the HTML of an item and writes it to render-output-buffer during the rendering of the
         * corresponding menu.Subclasses may override this function.
         * @param oRenderManager The <code>RenderManager</code> that can be used for writing to the
         * render-output-buffer
         * @param oItem The item which should be rendered
         * @param oMenu The menu to which this item belongs
        */
        render(oRenderManager: sap.ui.core.RenderManager, oItem: sap.ui.unified.MenuItemBase, oMenu: sap.ui.unified.Menu): void;

        /**
         * Sets a new value for property <code>enabled</code>.When an item is disabled the item can not be
         * selected by the user.The enabled property of the item has no effect when the menu of the item is
         * disabled ({@link sap.ui.unified.Menu#getEnabled Menu#getEnabled}).When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>true</code>.
         * @param bEnabled New value for property <code>enabled</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setEnabled(bEnabled: boolean): sap.ui.unified.MenuItemBase;

        /**
         * Sets a new value for property <code>startsSection</code>.Defines whether a visual separator should
         * be rendered before the item.<b>Note:</b> If an item is invisible also the separator of this item is
         * not shown.When called with a value of <code>null</code> or <code>undefined</code>, the default value
         * of the property will be restored.Default value is <code>false</code>.
         * @param bStartsSection New value for property <code>startsSection</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setStartsSection(bStartsSection: boolean): sap.ui.unified.MenuItemBase;

        /**
         * Sets the aggregated <code>submenu</code>.
         * @param oSubmenu The submenu to set
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setSubmenu(oSubmenu: sap.ui.unified.Menu): sap.ui.unified.MenuItemBase;

        /**
         * Sets a new value for property <code>visible</code>.Invisible items do not appear in the menu.When
         * called with a value of <code>null</code> or <code>undefined</code>, the default value of the
         * property will be restored.Default value is <code>true</code>.
         * @param bVisible New value for property <code>visible</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setVisible(bVisible: boolean): sap.ui.unified.MenuItemBase;
      }
      /**
       * The framework generates an input field and a button with text "Browse ...". The API supports
       * features such as on change uploads (the upload starts immediately after a file has been selected),
       * file uploads with explicit calls, adjustable control sizes, text display after uploads, or tooltips
       * containing complete file paths.
       * @resource sap/ui/unified/FileUploader.js
      */
      export class FileUploader extends sap.ui.core.Control {


        /**
         * Constructor for a new FileUploader.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);

        /**
         * Constructor for a new FileUploader.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(mSettings?: any);

        /**
         * Aborts the currently running upload.
         * @since 1.24.0
        */
        abort(): void;

        /**
         * Adds some headerParameter to the aggregation <code>headerParameters</code>.
         * @param oHeaderParameter the headerParameter to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addHeaderParameter(oHeaderParameter: sap.ui.unified.FileUploaderParameter): sap.ui.unified.FileUploader;

        /**
         * Adds some parameter to the aggregation <code>parameters</code>.
         * @since 1.12.2
         * @param oParameter the parameter to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addParameter(oParameter: sap.ui.unified.FileUploaderParameter): sap.ui.unified.FileUploader;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>change</code> event of this
         * <code>sap.ui.unified.FileUploader</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.unified.FileUploader</code> itself.Event is fired when the value of the file
         * path has been changed.
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.unified.FileUploader</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachChange(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.FileUploader;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>fileAllowed</code> event of this
         * <code>sap.ui.unified.FileUploader</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.unified.FileUploader</code> itself.Event is fired when the file is allowed for
         * upload on client side.
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.unified.FileUploader</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachFileAllowed(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.FileUploader;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>filenameLengthExceed</code> event of
         * this <code>sap.ui.unified.FileUploader</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.unified.FileUploader</code> itself.Event is fired, if the filename of a chosen
         * file is longer than the value specified with the maximumFilenameLength property.
         * @since 1.24.0
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.unified.FileUploader</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachFilenameLengthExceed(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.FileUploader;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>fileSizeExceed</code> event of this
         * <code>sap.ui.unified.FileUploader</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.unified.FileUploader</code> itself.Event is fired when the size of a file is
         * above the maximumFileSize property.This event is not supported by Internet Explorer 9 (same
         * restriction as for the property maximumFileSize).
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.unified.FileUploader</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachFileSizeExceed(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.FileUploader;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>typeMissmatch</code> event of this
         * <code>sap.ui.unified.FileUploader</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.unified.FileUploader</code> itself.Event is fired when the type of a file does
         * not match the mimeType or fileType property.
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.unified.FileUploader</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachTypeMissmatch(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.FileUploader;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>uploadAborted</code> event of this
         * <code>sap.ui.unified.FileUploader</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.unified.FileUploader</code> itself.Event is fired after the current upload has
         * been aborted.This is event is only supported with property sendXHR set to true, i.e. the event is
         * not supported in Internet Explorer 9.
         * @since 1.24.0
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.unified.FileUploader</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachUploadAborted(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.FileUploader;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>uploadComplete</code> event of this
         * <code>sap.ui.unified.FileUploader</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.unified.FileUploader</code> itself.Event is fired as soon as the upload request
         * is completed (either successful or unsuccessful). To see if the upload request was successful, check
         * the 'state' parameter for a value 2xx.The uploads actual progress can be retrieved via the
         * 'uploadProgress' Event.However this covers only the client side of the Upload process and does not
         * give any success status from the server.
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.unified.FileUploader</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachUploadComplete(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.FileUploader;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>uploadProgress</code> event of this
         * <code>sap.ui.unified.FileUploader</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.unified.FileUploader</code> itself.Event is fired after the upload has started
         * and before the upload is completed and contains progress information related to the running
         * upload.Depending on file size, band width and used browser the event is fired once or multiple
         * times.This is event is only supported with property sendXHR set to true, i.e. the event is not
         * supported in Internet Explorer 9.
         * @since 1.24.0
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.unified.FileUploader</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachUploadProgress(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.FileUploader;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>uploadStart</code> event of this
         * <code>sap.ui.unified.FileUploader</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.unified.FileUploader</code> itself.Event is fired before an upload is started.
         * @since 1.30.0
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.unified.FileUploader</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachUploadStart(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.FileUploader;

        /**
         * Clears the content of the FileUploader. The attached additional data however is retained.
         * @since 1.25.0
        */
        clear(): void;

        /**
         * Destroys all the headerParameters in the aggregation <code>headerParameters</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyHeaderParameters(): sap.ui.unified.FileUploader;

        /**
         * Destroys all the parameters in the aggregation <code>parameters</code>.
         * @since 1.12.2
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyParameters(): sap.ui.unified.FileUploader;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>change</code> event of this
         * <code>sap.ui.unified.FileUploader</code>.The passed function and listener object must match the ones
         * used for event registration.
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachChange(fnFunction: any, oListener: any): sap.ui.unified.FileUploader;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>fileAllowed</code> event of this
         * <code>sap.ui.unified.FileUploader</code>.The passed function and listener object must match the ones
         * used for event registration.
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachFileAllowed(fnFunction: any, oListener: any): sap.ui.unified.FileUploader;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>filenameLengthExceed</code> event of
         * this <code>sap.ui.unified.FileUploader</code>.The passed function and listener object must match the
         * ones used for event registration.
         * @since 1.24.0
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachFilenameLengthExceed(fnFunction: any, oListener: any): sap.ui.unified.FileUploader;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>fileSizeExceed</code> event of this
         * <code>sap.ui.unified.FileUploader</code>.The passed function and listener object must match the ones
         * used for event registration.
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachFileSizeExceed(fnFunction: any, oListener: any): sap.ui.unified.FileUploader;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>typeMissmatch</code> event of this
         * <code>sap.ui.unified.FileUploader</code>.The passed function and listener object must match the ones
         * used for event registration.
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachTypeMissmatch(fnFunction: any, oListener: any): sap.ui.unified.FileUploader;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>uploadAborted</code> event of this
         * <code>sap.ui.unified.FileUploader</code>.The passed function and listener object must match the ones
         * used for event registration.
         * @since 1.24.0
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachUploadAborted(fnFunction: any, oListener: any): sap.ui.unified.FileUploader;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>uploadComplete</code> event of this
         * <code>sap.ui.unified.FileUploader</code>.The passed function and listener object must match the ones
         * used for event registration.
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachUploadComplete(fnFunction: any, oListener: any): sap.ui.unified.FileUploader;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>uploadProgress</code> event of this
         * <code>sap.ui.unified.FileUploader</code>.The passed function and listener object must match the ones
         * used for event registration.
         * @since 1.24.0
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachUploadProgress(fnFunction: any, oListener: any): sap.ui.unified.FileUploader;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>uploadStart</code> event of this
         * <code>sap.ui.unified.FileUploader</code>.The passed function and listener object must match the ones
         * used for event registration.
         * @since 1.30.0
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachUploadStart(fnFunction: any, oListener: any): sap.ui.unified.FileUploader;


        /**
         * Fires event <code>change</code> to attached listeners.Expects the following event
         * parameters:<ul><li><code>newValue</code> of type <code>string</code>New file path
         * value.</li><li><code>files</code> of type <code>object[]</code>Files.</li></ul>
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireChange(mArguments: any): sap.ui.unified.FileUploader;

        /**
         * Fires event <code>fileAllowed</code> to attached listeners.
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireFileAllowed(mArguments: any): sap.ui.unified.FileUploader;

        /**
         * Fires event <code>filenameLengthExceed</code> to attached listeners.Expects the following event
         * parameters:<ul><li><code>fileName</code> of type <code>string</code>The filename, which is longer
         * than specified by the value of the property maximumFilenameLength.</li></ul>
         * @since 1.24.0
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireFilenameLengthExceed(mArguments: any): sap.ui.unified.FileUploader;

        /**
         * Fires event <code>fileSizeExceed</code> to attached listeners.Expects the following event
         * parameters:<ul><li><code>fileName</code> of type <code>string</code>The name of a file to be
         * uploaded.</li><li><code>fileSize</code> of type <code>string</code>The size in MB of a file to be
         * uploaded.</li></ul>
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireFileSizeExceed(mArguments: any): sap.ui.unified.FileUploader;

        /**
         * Fires event <code>typeMissmatch</code> to attached listeners.Expects the following event
         * parameters:<ul><li><code>fileName</code> of type <code>string</code>The name of a file to be
         * uploaded.</li><li><code>fileType</code> of type <code>string</code>The file ending of a file to be
         * uploaded.</li><li><code>mimeType</code> of type <code>string</code>The MIME type of a file to be
         * uploaded.</li></ul>
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireTypeMissmatch(mArguments: any): sap.ui.unified.FileUploader;

        /**
         * Fires event <code>uploadAborted</code> to attached listeners.Expects the following event
         * parameters:<ul><li><code>fileName</code> of type <code>string</code>The name of a file to be
         * uploaded.</li><li><code>requestHeaders</code> of type <code>object[]</code>Http-Request-Headers.
         * Required for receiving "header" is to set the property "sendXHR" to true.This property is not
         * supported by Internet Explorer 9.</li></ul>
         * @since 1.24.0
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireUploadAborted(mArguments: any): sap.ui.unified.FileUploader;

        /**
         * Fires event <code>uploadComplete</code> to attached listeners.Expects the following event
         * parameters:<ul><li><code>fileName</code> of type <code>string</code>The name of a file to be
         * uploaded.</li><li><code>response</code> of type <code>string</code>Response message which comes from
         * the server. On the server side this response has to be put within the &quot;body&quot; tags of the
         * response document of the iFrame.It can consist of a return code and an optional message. This does
         * not work in cross-domain scenarios.</li><li><code>readyStateXHR</code> of type
         * <code>string</code>ReadyState of the XHR request. Required for receiving a readyState is to set the
         * property "sendXHR" to "true". This property is not supported by Internet Explorer
         * 9.</li><li><code>status</code> of type <code>string</code>Status of the XHR request. Required for
         * receiving a status is to set the property "sendXHR" to "true". This property is not supported by
         * Internet Explorer 9.</li><li><code>responseRaw</code> of type <code>string</code>Http-Response which
         * comes from the server. Required for receiving "responseRaw" is to set the property "sendXHR" to
         * true. This property is not supported by Internet Explorer 9.</li><li><code>headers</code> of type
         * <code>object</code>Http-Response-Headers which come from the server. provided as a JSON-map, i.e.
         * each header-field is reflected by a property in the header-object, with the property value
         * reflecting the header-field's content.Required for receiving "header" is to set the property
         * "sendXHR" to true.This property is not supported by Internet Explorer
         * 9.</li><li><code>requestHeaders</code> of type <code>object[]</code>Http-Request-Headers. Required
         * for receiving "header" is to set the property "sendXHR" to true. This property is not supported by
         * Internet Explorer 9.</li></ul>
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireUploadComplete(mArguments: any): sap.ui.unified.FileUploader;

        /**
         * Fires event <code>uploadProgress</code> to attached listeners.Expects the following event
         * parameters:<ul><li><code>lengthComputable</code> of type <code>boolean</code>Indicates whether or
         * not the relative upload progress can be calculated out of loaded and
         * total.</li><li><code>loaded</code> of type <code>float</code>The number of bytes of the file which
         * have been uploaded by to the time the event was fired.</li><li><code>total</code> of type
         * <code>float</code>The total size of the file to be uploaded in byte.</li><li><code>fileName</code>
         * of type <code>string</code>The name of a file to be uploaded.</li><li><code>requestHeaders</code> of
         * type <code>object[]</code>Http-Request-Headers. Required for receiving "header" is to set the
         * property "sendXHR" to true.This property is not supported by Internet Explorer 9.</li></ul>
         * @since 1.24.0
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireUploadProgress(mArguments: any): sap.ui.unified.FileUploader;

        /**
         * Fires event <code>uploadStart</code> to attached listeners.Expects the following event
         * parameters:<ul><li><code>fileName</code> of type <code>string</code>The name of a file to be
         * uploaded.</li><li><code>requestHeaders</code> of type <code>object[]</code>Http-Request-Headers.
         * Required for receiving "header" is to set the property "sendXHR" to true.This property is not
         * supported by Internet Explorer 9.</li></ul>
         * @since 1.30.0
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireUploadStart(mArguments: any): sap.ui.unified.FileUploader;

        /**
         * Gets current value of property <code>additionalData</code>.Additional data that is sent to the back
         * end service. Data will be transmitted as value of a hidden input where the name is derived from the
         * name property with suffix -data.
         * @returns Value of property <code>additionalData</code>
        */
        getAdditionalData(): string;

        /**
         * Gets current value of property <code>buttonOnly</code>.If set to "true", the FileUploader will be
         * rendered as Button only, without showing the InputField.Default value is <code>false</code>.
         * @returns Value of property <code>buttonOnly</code>
        */
        getButtonOnly(): boolean;

        /**
         * Gets current value of property <code>buttonText</code>.The Button text can be overwritten using this
         * property.
         * @returns Value of property <code>buttonText</code>
        */
        getButtonText(): string;

        /**
         * Gets current value of property <code>enabled</code>.Disabled controls have different colors,
         * depending on customer settings.Default value is <code>true</code>.
         * @returns Value of property <code>enabled</code>
        */
        getEnabled(): boolean;

        /**
         * Gets current value of property <code>fileType</code>.The chosen files will be checked against an
         * array of file types. If at least one file does not fit the file type restriction the upload is
         * prevented.Example: ["jpg", "png", "bmp"].
         * @returns Value of property <code>fileType</code>
        */
        getFileType(): string[];

        /**
         * Gets content of aggregation <code>headerParameters</code>.The header parameters for the FileUploader
         * which are only submitted with XHR requests. Header parameters are not supported by Internet Explorer
         * 9.
        */
        getHeaderParameters(): sap.ui.unified.FileUploaderParameter[];

        /**
         * Gets current value of property <code>icon</code>.Icon to be displayed as graphical element within
         * the button.This can be an URI to an image or an icon font URI.Default value is <code></code>.
         * @since 1.26.0
         * @returns Value of property <code>icon</code>
        */
        getIcon(): any;

        /**
         * Gets current value of property <code>iconFirst</code>.If set to true (default), the display sequence
         * is 1. icon 2. control text.Default value is <code>true</code>.
         * @since 1.26.0
         * @returns Value of property <code>iconFirst</code>
        */
        getIconFirst(): boolean;

        /**
         * Gets current value of property <code>iconHovered</code>.Icon to be displayed as graphical element
         * within the button when it is hovered (only if also a base icon was specified). If not specified the
         * base icon is used.If a icon font icon is used, this property is ignored.Default value is
         * <code></code>.
         * @since 1.26.0
         * @returns Value of property <code>iconHovered</code>
        */
        getIconHovered(): any;

        /**
         * Gets current value of property <code>iconOnly</code>.If set to true, the button is displayed without
         * any text.Default value is <code>false</code>.
         * @since 1.26.0
         * @returns Value of property <code>iconOnly</code>
        */
        getIconOnly(): boolean;

        /**
         * Gets current value of property <code>iconSelected</code>.Icon to be displayed as graphical element
         * within the button when it is selected (only if also a base icon was specified). If not specified the
         * base or hovered icon is used.If a icon font icon is used, this property is ignored.Default value is
         * <code></code>.
         * @since 1.26.0
         * @returns Value of property <code>iconSelected</code>
        */
        getIconSelected(): any;

        /**
         * Gets current value of property <code>maximumFilenameLength</code>.The maximum length of a filename
         * which the FileUploader will accept. If the maximum filename length is exceeded, the corresponding
         * Event 'filenameLengthExceed' is fired.
         * @since 1.24.0
         * @returns Value of property <code>maximumFilenameLength</code>
        */
        getMaximumFilenameLength(): number;

        /**
         * Gets current value of property <code>maximumFileSize</code>.A file size limit in megabytes which
         * prevents the upload if at least one file exceeds it. This property is not supported by Internet
         * Explorer 9.
         * @returns Value of property <code>maximumFileSize</code>
        */
        getMaximumFileSize(): number;

        /**
         * Returns a metadata object for class sap.ui.unified.FileUploader.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>mimeType</code>.The chosen files will be checked against an
         * array of mime types. If at least one file does not fit the mime type restriction the upload is
         * prevented. This property is not supported by Internet Explorer 9.Example: mimeType ["image/png",
         * "image/jpeg"].
         * @returns Value of property <code>mimeType</code>
        */
        getMimeType(): string[];

        /**
         * Gets current value of property <code>multiple</code>.Allows multiple files to be chosen and uploaded
         * from the same folder. This property is not supported by Internet Explorer 9.Default value is
         * <code>false</code>.
         * @returns Value of property <code>multiple</code>
        */
        getMultiple(): boolean;

        /**
         * Gets current value of property <code>name</code>.Unique control name for identification on the
         * server side after sending data to the server.
         * @returns Value of property <code>name</code>
        */
        getName(): string;

        /**
         * Gets content of aggregation <code>parameters</code>.The parameters for the FileUploader which are
         * rendered as a hidden inputfield.
         * @since 1.12.2
        */
        getParameters(): sap.ui.unified.FileUploaderParameter[];

        /**
         * Gets current value of property <code>placeholder</code>.Placeholder for the text field.
         * @returns Value of property <code>placeholder</code>
        */
        getPlaceholder(): string;

        /**
         * Gets current value of property <code>sameFilenameAllowed</code>.If the FileUploader is configured to
         * upload the file directly after the file is selected it is not allowed to upload a file with the same
         * name again. If a user should be allowed to upload a file with the same name again this parameter has
         * to be "true". A typical use case would be if the files have different paths.Default value is
         * <code>false</code>.
         * @returns Value of property <code>sameFilenameAllowed</code>
        */
        getSameFilenameAllowed(): boolean;

        /**
         * Gets current value of property <code>sendXHR</code>.If set to "true", the request will be sent as
         * XHR request instead of a form submit. This property is not supported by Internet Explorer 9.Default
         * value is <code>false</code>.
         * @returns Value of property <code>sendXHR</code>
        */
        getSendXHR(): boolean;

        /**
         * Gets current value of property <code>style</code>.Style of the button. "Transparent, "Accept",
         * "Reject", or "Emphasized" is allowed.
         * @returns Value of property <code>style</code>
        */
        getStyle(): string;

        /**
         * Gets current value of property <code>uploadOnChange</code>.If set to "true", the upload immediately
         * starts after file selection. With the default setting, the upload needs to be explicitly
         * triggered.Default value is <code>false</code>.
         * @returns Value of property <code>uploadOnChange</code>
        */
        getUploadOnChange(): boolean;

        /**
         * Gets current value of property <code>uploadUrl</code>.Used when URL address is on a remote
         * server.Default value is <code></code>.
         * @returns Value of property <code>uploadUrl</code>
        */
        getUploadUrl(): any;

        /**
         * Gets current value of property <code>useMultipart</code>.If set to "false", the request will be sent
         * as file only request instead of a multipart/form-data request. Only one file could be uploaded using
         * this type of request. Required for sending such a request is to set the property "sendXHR" to
         * "true". This property is not supported by Internet Explorer 9.Default value is <code>true</code>.
         * @returns Value of property <code>useMultipart</code>
        */
        getUseMultipart(): boolean;

        /**
         * Gets current value of property <code>value</code>.Value of the path for file upload.Default value is
         * <code></code>.
         * @returns Value of property <code>value</code>
        */
        getValue(): string;

        /**
         * Gets current value of property <code>valueState</code>.Visualizes warnings or errors related to the
         * text field. Possible values: Warning, Error, Success, None.Default value is <code>None</code>.
         * @since 1.24.0
         * @returns Value of property <code>valueState</code>
        */
        getValueState(): sap.ui.core.ValueState;

        /**
         * Gets current value of property <code>width</code>.Specifies the displayed control width.Default
         * value is <code></code>.
         * @returns Value of property <code>width</code>
        */
        getWidth(): any;

        /**
         * Checks for the provided <code>sap.ui.unified.FileUploaderParameter</code> in the aggregation
         * <code>headerParameters</code>.and returns its index if found or -1 otherwise.
         * @param oHeaderParameter The headerParameter whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfHeaderParameter(oHeaderParameter: sap.ui.unified.FileUploaderParameter): number;

        /**
         * Checks for the provided <code>sap.ui.unified.FileUploaderParameter</code> in the aggregation
         * <code>parameters</code>.and returns its index if found or -1 otherwise.
         * @since 1.12.2
         * @param oParameter The parameter whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfParameter(oParameter: sap.ui.unified.FileUploaderParameter): number;

        /**
         * Inserts a headerParameter into the aggregation <code>headerParameters</code>.
         * @param oHeaderParameter the headerParameter to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the headerParameter should be inserted at; for         
         *    a negative value of <code>iIndex</code>, the headerParameter is inserted at position 0; for a
         * value             greater than the current size of the aggregation, the headerParameter is inserted
         * at             the last position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertHeaderParameter(oHeaderParameter: sap.ui.unified.FileUploaderParameter, iIndex: number): sap.ui.unified.FileUploader;

        /**
         * Inserts a parameter into the aggregation <code>parameters</code>.
         * @since 1.12.2
         * @param oParameter the parameter to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the parameter should be inserted at; for             a
         * negative value of <code>iIndex</code>, the parameter is inserted at position 0; for a value         
         *    greater than the current size of the aggregation, the parameter is inserted at             the
         * last position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertParameter(oParameter: sap.ui.unified.FileUploaderParameter, iIndex: number): sap.ui.unified.FileUploader;

        /**
         * Removes all the controls from the aggregation <code>headerParameters</code>.Additionally, it
         * unregisters them from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllHeaderParameters(): sap.ui.unified.FileUploaderParameter[];

        /**
         * Removes all the controls from the aggregation <code>parameters</code>.Additionally, it unregisters
         * them from the hosting UIArea.
         * @since 1.12.2
         * @returns An array of the removed elements (might be empty)
        */
        removeAllParameters(): sap.ui.unified.FileUploaderParameter[];

        /**
         * Removes a headerParameter from the aggregation <code>headerParameters</code>.
         * @param vHeaderParameter The headerParameter to remove or its index or id
         * @returns The removed headerParameter or <code>null</code>
        */
        removeHeaderParameter(vHeaderParameter: number | string | sap.ui.unified.FileUploaderParameter): sap.ui.unified.FileUploaderParameter;

        /**
         * Removes a parameter from the aggregation <code>parameters</code>.
         * @since 1.12.2
         * @param vParameter The parameter to remove or its index or id
         * @returns The removed parameter or <code>null</code>
        */
        removeParameter(vParameter: number | string | sap.ui.unified.FileUploaderParameter): sap.ui.unified.FileUploaderParameter;

        /**
         * Sets a new value for property <code>additionalData</code>.Additional data that is sent to the back
         * end service. Data will be transmitted as value of a hidden input where the name is derived from the
         * name property with suffix -data.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.
         * @param sAdditionalData New value for property <code>additionalData</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setAdditionalData(sAdditionalData: string): sap.ui.unified.FileUploader;

        /**
         * Sets a new value for property <code>buttonOnly</code>.If set to "true", the FileUploader will be
         * rendered as Button only, without showing the InputField.When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>false</code>.
         * @param bButtonOnly New value for property <code>buttonOnly</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setButtonOnly(bButtonOnly: boolean): sap.ui.unified.FileUploader;

        /**
         * Sets a new value for property <code>buttonText</code>.The Button text can be overwritten using this
         * property.When called with a value of <code>null</code> or <code>undefined</code>, the default value
         * of the property will be restored.
         * @param sButtonText New value for property <code>buttonText</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setButtonText(sButtonText: string): sap.ui.unified.FileUploader;

        /**
         * Sets a new value for property <code>enabled</code>.Disabled controls have different colors,
         * depending on customer settings.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.Default value is
         * <code>true</code>.
         * @param bEnabled New value for property <code>enabled</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setEnabled(bEnabled: boolean): sap.ui.unified.FileUploader;

        /**
         * Sets a new value for property <code>fileType</code>.The chosen files will be checked against an
         * array of file types. If at least one file does not fit the file type restriction the upload is
         * prevented.Example: ["jpg", "png", "bmp"].When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.
         * @param sFileType New value for property <code>fileType</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setFileType(sFileType: string[]): sap.ui.unified.FileUploader;

        /**
         * Sets a new value for property <code>icon</code>.Icon to be displayed as graphical element within the
         * button.This can be an URI to an image or an icon font URI.When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code></code>.
         * @since 1.26.0
         * @param sIcon New value for property <code>icon</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setIcon(sIcon: any): sap.ui.unified.FileUploader;

        /**
         * Sets a new value for property <code>iconFirst</code>.If set to true (default), the display sequence
         * is 1. icon 2. control text.When called with a value of <code>null</code> or <code>undefined</code>,
         * the default value of the property will be restored.Default value is <code>true</code>.
         * @since 1.26.0
         * @param bIconFirst New value for property <code>iconFirst</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setIconFirst(bIconFirst: boolean): sap.ui.unified.FileUploader;

        /**
         * Sets a new value for property <code>iconHovered</code>.Icon to be displayed as graphical element
         * within the button when it is hovered (only if also a base icon was specified). If not specified the
         * base icon is used.If a icon font icon is used, this property is ignored.When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code></code>.
         * @since 1.26.0
         * @param sIconHovered New value for property <code>iconHovered</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setIconHovered(sIconHovered: any): sap.ui.unified.FileUploader;

        /**
         * Sets a new value for property <code>iconOnly</code>.If set to true, the button is displayed without
         * any text.When called with a value of <code>null</code> or <code>undefined</code>, the default value
         * of the property will be restored.Default value is <code>false</code>.
         * @since 1.26.0
         * @param bIconOnly New value for property <code>iconOnly</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setIconOnly(bIconOnly: boolean): sap.ui.unified.FileUploader;

        /**
         * Sets a new value for property <code>iconSelected</code>.Icon to be displayed as graphical element
         * within the button when it is selected (only if also a base icon was specified). If not specified the
         * base or hovered icon is used.If a icon font icon is used, this property is ignored.When called with
         * a value of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code></code>.
         * @since 1.26.0
         * @param sIconSelected New value for property <code>iconSelected</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setIconSelected(sIconSelected: any): sap.ui.unified.FileUploader;

        /**
         * Sets a new value for property <code>maximumFilenameLength</code>.The maximum length of a filename
         * which the FileUploader will accept. If the maximum filename length is exceeded, the corresponding
         * Event 'filenameLengthExceed' is fired.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.
         * @since 1.24.0
         * @param iMaximumFilenameLength New value for property <code>maximumFilenameLength</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setMaximumFilenameLength(iMaximumFilenameLength: number): sap.ui.unified.FileUploader;

        /**
         * Sets a new value for property <code>maximumFileSize</code>.A file size limit in megabytes which
         * prevents the upload if at least one file exceeds it. This property is not supported by Internet
         * Explorer 9.When called with a value of <code>null</code> or <code>undefined</code>, the default
         * value of the property will be restored.
         * @param fMaximumFileSize New value for property <code>maximumFileSize</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setMaximumFileSize(fMaximumFileSize: number): sap.ui.unified.FileUploader;

        /**
         * Sets a new value for property <code>mimeType</code>.The chosen files will be checked against an
         * array of mime types. If at least one file does not fit the mime type restriction the upload is
         * prevented. This property is not supported by Internet Explorer 9.Example: mimeType ["image/png",
         * "image/jpeg"].When called with a value of <code>null</code> or <code>undefined</code>, the default
         * value of the property will be restored.
         * @param sMimeType New value for property <code>mimeType</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setMimeType(sMimeType: string[]): sap.ui.unified.FileUploader;

        /**
         * Sets a new value for property <code>multiple</code>.Allows multiple files to be chosen and uploaded
         * from the same folder. This property is not supported by Internet Explorer 9.When called with a value
         * of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>false</code>.
         * @param bMultiple New value for property <code>multiple</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setMultiple(bMultiple: boolean): sap.ui.unified.FileUploader;

        /**
         * Sets a new value for property <code>name</code>.Unique control name for identification on the server
         * side after sending data to the server.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.
         * @param sName New value for property <code>name</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setName(sName: string): sap.ui.unified.FileUploader;

        /**
         * Sets a new value for property <code>placeholder</code>.Placeholder for the text field.When called
         * with a value of <code>null</code> or <code>undefined</code>, the default value of the property will
         * be restored.
         * @param sPlaceholder New value for property <code>placeholder</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setPlaceholder(sPlaceholder: string): sap.ui.unified.FileUploader;

        /**
         * Sets a new value for property <code>sameFilenameAllowed</code>.If the FileUploader is configured to
         * upload the file directly after the file is selected it is not allowed to upload a file with the same
         * name again. If a user should be allowed to upload a file with the same name again this parameter has
         * to be "true". A typical use case would be if the files have different paths.When called with a value
         * of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>false</code>.
         * @param bSameFilenameAllowed New value for property <code>sameFilenameAllowed</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setSameFilenameAllowed(bSameFilenameAllowed: boolean): sap.ui.unified.FileUploader;

        /**
         * Sets a new value for property <code>sendXHR</code>.If set to "true", the request will be sent as XHR
         * request instead of a form submit. This property is not supported by Internet Explorer 9.When called
         * with a value of <code>null</code> or <code>undefined</code>, the default value of the property will
         * be restored.Default value is <code>false</code>.
         * @param bSendXHR New value for property <code>sendXHR</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setSendXHR(bSendXHR: boolean): sap.ui.unified.FileUploader;

        /**
         * Sets a new value for property <code>style</code>.Style of the button. "Transparent, "Accept",
         * "Reject", or "Emphasized" is allowed.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.
         * @param sStyle New value for property <code>style</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setStyle(sStyle: string): sap.ui.unified.FileUploader;

        /**
         * Sets a new value for property <code>uploadOnChange</code>.If set to "true", the upload immediately
         * starts after file selection. With the default setting, the upload needs to be explicitly
         * triggered.When called with a value of <code>null</code> or <code>undefined</code>, the default value
         * of the property will be restored.Default value is <code>false</code>.
         * @param bUploadOnChange New value for property <code>uploadOnChange</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setUploadOnChange(bUploadOnChange: boolean): sap.ui.unified.FileUploader;

        /**
         * Sets a new value for property <code>uploadUrl</code>.Used when URL address is on a remote
         * server.When called with a value of <code>null</code> or <code>undefined</code>, the default value of
         * the property will be restored.Default value is <code></code>.
         * @param sUploadUrl New value for property <code>uploadUrl</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setUploadUrl(sUploadUrl: any): sap.ui.unified.FileUploader;

        /**
         * Sets a new value for property <code>useMultipart</code>.If set to "false", the request will be sent
         * as file only request instead of a multipart/form-data request. Only one file could be uploaded using
         * this type of request. Required for sending such a request is to set the property "sendXHR" to
         * "true". This property is not supported by Internet Explorer 9.When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>true</code>.
         * @param bUseMultipart New value for property <code>useMultipart</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setUseMultipart(bUseMultipart: boolean): sap.ui.unified.FileUploader;

        /**
         * Sets a new value for property <code>value</code>.Value of the path for file upload.When called with
         * a value of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code></code>.
         * @param sValue New value for property <code>value</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setValue(sValue: string): sap.ui.unified.FileUploader;

        /**
         * Sets a new value for property <code>valueState</code>.Visualizes warnings or errors related to the
         * text field. Possible values: Warning, Error, Success, None.When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>None</code>.
         * @since 1.24.0
         * @param sValueState New value for property <code>valueState</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setValueState(sValueState: sap.ui.core.ValueState): sap.ui.unified.FileUploader;

        /**
         * Sets a new value for property <code>width</code>.Specifies the displayed control width.When called
         * with a value of <code>null</code> or <code>undefined</code>, the default value of the property will
         * be restored.Default value is <code></code>.
         * @param sWidth New value for property <code>width</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setWidth(sWidth: any): sap.ui.unified.FileUploader;

        /**
         * Starts the upload (as defined by uploadUrl)
        */
        upload(): void;
      }
      /**
       * Date range with calendar day type information. Used to visualize special days in the Calendar.
       * @resource sap/ui/unified/DateTypeRange.js
      */
      export class DateTypeRange extends sap.ui.unified.DateRange {


        /**
         * Constructor for a new DateTypeRange.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);




        /**
         * Returns a metadata object for class sap.ui.unified.DateTypeRange.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>type</code>.Type of the date range.Default value is
         * <code>Type01</code>.
         * @returns Value of property <code>type</code>
        */
        getType(): sap.ui.unified.CalendarDayType;

        /**
         * Sets a new value for property <code>type</code>.Type of the date range.When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>Type01</code>.
         * @param sType New value for property <code>type</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setType(sType: sap.ui.unified.CalendarDayType): sap.ui.unified.DateTypeRange;
      }
      /**
       * Header Action item of the Shell.
       * @resource sap/ui/unified/ShellHeadItem.js
      */
      export class ShellHeadItem extends sap.ui.core.Element {


        /**
         * Constructor for a new ShellHeadItem.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Adds some ariaLabelledBy into the association <code>ariaLabelledBy</code>.
         * @param vAriaLabelledBy the ariaLabelledBy to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addAriaLabelledBy(vAriaLabelledBy: any | sap.ui.core.Control): sap.ui.unified.ShellHeadItem;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>press</code> event of this
         * <code>sap.ui.unified.ShellHeadItem</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.unified.ShellHeadItem</code> itself.Event is fired when the user presses the
         * item.
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.unified.ShellHeadItem</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachPress(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.ShellHeadItem;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>press</code> event of this
         * <code>sap.ui.unified.ShellHeadItem</code>.The passed function and listener object must match the
         * ones used for event registration.
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachPress(fnFunction: any, oListener: any): sap.ui.unified.ShellHeadItem;


        /**
         * Fires event <code>press</code> to attached listeners.
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        firePress(mArguments: any): sap.ui.unified.ShellHeadItem;

        /**
         * Returns array of IDs of the elements which are the current targets of the association
         * <code>ariaLabelledBy</code>.
        */
        getAriaLabelledBy(): any[];

        /**
         * Gets current value of property <code>icon</code>.The icon of the item, either defined in the
         * sap.ui.core.IconPool or an URI to a custom image. An icon must be set.
         * @returns Value of property <code>icon</code>
        */
        getIcon(): any;

        /**
         * Returns a metadata object for class sap.ui.unified.ShellHeadItem.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>selected</code>.Defines the toggle state in case the item
         * represents a toggle button (see also property <code>toggleEnabled</code>).Default value is
         * <code>false</code>.
         * @returns Value of property <code>selected</code>
        */
        getSelected(): boolean;

        /**
         * Gets current value of property <code>showMarker</code>.If set to true, a theme dependent marker is
         * shown on the item.Default value is <code>false</code>.
         * @returns Value of property <code>showMarker</code>
        */
        getShowMarker(): boolean;

        /**
         * Gets current value of property <code>showSeparator</code>.If set to true, a separator is displayed
         * after the item.Default value is <code>true</code>.
         * @since 1.22.5
         * @returns Value of property <code>showSeparator</code>
        */
        getShowSeparator(): boolean;

        /**
         * Gets current value of property <code>startsSection</code>.If set to true, a divider is displayed
         * before the item.Default value is <code>false</code>.
         * @returns Value of property <code>startsSection</code>
        */
        getStartsSection(): boolean;

        /**
         * Gets current value of property <code>toggleEnabled</code>.If set to true, the item represents a
         * toggle button. The <code>selected</code> property can the be used todefine the toggle state.
         * Otherwise the item is displayed as action button. In this case the <code>selected</code> propertyis
         * ignored.Default value is <code>true</code>.
         * @since 1.34.3
         * @returns Value of property <code>toggleEnabled</code>
        */
        getToggleEnabled(): boolean;

        /**
         * Gets current value of property <code>visible</code>.Invisible items are not shown on the UI.Default
         * value is <code>true</code>.
         * @since 1.18
         * @returns Value of property <code>visible</code>
        */
        getVisible(): boolean;

        /**
         * Removes all the controls in the association named <code>ariaLabelledBy</code>.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllAriaLabelledBy(): any[];

        /**
         * Removes an ariaLabelledBy from the association named <code>ariaLabelledBy</code>.
         * @param vAriaLabelledBy The ariaLabelledBy to be removed or its index or ID
         * @returns The removed ariaLabelledBy or <code>null</code>
        */
        removeAriaLabelledBy(vAriaLabelledBy: number | any | sap.ui.core.Control): any;

        /**
         * Sets a new value for property <code>icon</code>.The icon of the item, either defined in the
         * sap.ui.core.IconPool or an URI to a custom image. An icon must be set.When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
         * @param sIcon New value for property <code>icon</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setIcon(sIcon: any): sap.ui.unified.ShellHeadItem;

        /**
         * Sets a new value for property <code>selected</code>.Defines the toggle state in case the item
         * represents a toggle button (see also property <code>toggleEnabled</code>).When called with a value
         * of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>false</code>.
         * @param bSelected New value for property <code>selected</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setSelected(bSelected: boolean): sap.ui.unified.ShellHeadItem;

        /**
         * Sets a new value for property <code>showMarker</code>.If set to true, a theme dependent marker is
         * shown on the item.When called with a value of <code>null</code> or <code>undefined</code>, the
         * default value of the property will be restored.Default value is <code>false</code>.
         * @param bShowMarker New value for property <code>showMarker</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setShowMarker(bShowMarker: boolean): sap.ui.unified.ShellHeadItem;

        /**
         * Sets a new value for property <code>showSeparator</code>.If set to true, a separator is displayed
         * after the item.When called with a value of <code>null</code> or <code>undefined</code>, the default
         * value of the property will be restored.Default value is <code>true</code>.
         * @since 1.22.5
         * @param bShowSeparator New value for property <code>showSeparator</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setShowSeparator(bShowSeparator: boolean): sap.ui.unified.ShellHeadItem;

        /**
         * Sets a new value for property <code>startsSection</code>.If set to true, a divider is displayed
         * before the item.When called with a value of <code>null</code> or <code>undefined</code>, the default
         * value of the property will be restored.Default value is <code>false</code>.
         * @param bStartsSection New value for property <code>startsSection</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setStartsSection(bStartsSection: boolean): sap.ui.unified.ShellHeadItem;

        /**
         * Sets a new value for property <code>toggleEnabled</code>.If set to true, the item represents a
         * toggle button. The <code>selected</code> property can the be used todefine the toggle state.
         * Otherwise the item is displayed as action button. In this case the <code>selected</code> propertyis
         * ignored.When called with a value of <code>null</code> or <code>undefined</code>, the default value
         * of the property will be restored.Default value is <code>true</code>.
         * @since 1.34.3
         * @param bToggleEnabled New value for property <code>toggleEnabled</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setToggleEnabled(bToggleEnabled: boolean): sap.ui.unified.ShellHeadItem;

        /**
         * Sets a new value for property <code>visible</code>.Invisible items are not shown on the UI.When
         * called with a value of <code>null</code> or <code>undefined</code>, the default value of the
         * property will be restored.Default value is <code>true</code>.
         * @since 1.18
         * @param bVisible New value for property <code>visible</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setVisible(bVisible: boolean): sap.ui.unified.ShellHeadItem;
      }
      /**
       * A legend for the Calendar Control. Displays special dates colors with their corresponding
       * description. The aggregation specialDates can be set herefor.
       * @resource sap/ui/unified/CalendarLegend.js
      */
      export class CalendarLegend extends sap.ui.core.Control {


        /**
         * Constructor for a new CalendarLegend.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Adds some item to the aggregation <code>items</code>.
         * @param oItem the item to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addItem(oItem: sap.ui.unified.CalendarLegendItem): sap.ui.unified.CalendarLegend;

        /**
         * Destroys all the items in the aggregation <code>items</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyItems(): sap.ui.unified.CalendarLegend;


        /**
         * Gets current value of property <code>columnWidth</code>.Width of the columns created in which the
         * items are arranged.Default value is <code>120px</code>.
         * @returns Value of property <code>columnWidth</code>
        */
        getColumnWidth(): any;

        /**
         * Gets content of aggregation <code>items</code>.Items to be displayed.
        */
        getItems(): sap.ui.unified.CalendarLegendItem[];

        /**
         * Returns a metadata object for class sap.ui.unified.CalendarLegend.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Checks for the provided <code>sap.ui.unified.CalendarLegendItem</code> in the aggregation
         * <code>items</code>.and returns its index if found or -1 otherwise.
         * @param oItem The item whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfItem(oItem: sap.ui.unified.CalendarLegendItem): number;

        /**
         * Inserts a item into the aggregation <code>items</code>.
         * @param oItem the item to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the item should be inserted at; for             a
         * negative value of <code>iIndex</code>, the item is inserted at position 0; for a value            
         * greater than the current size of the aggregation, the item is inserted at             the last
         * position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertItem(oItem: sap.ui.unified.CalendarLegendItem, iIndex: number): sap.ui.unified.CalendarLegend;

        /**
         * Removes all the controls from the aggregation <code>items</code>.Additionally, it unregisters them
         * from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllItems(): sap.ui.unified.CalendarLegendItem[];

        /**
         * Removes a item from the aggregation <code>items</code>.
         * @param vItem The item to remove or its index or id
         * @returns The removed item or <code>null</code>
        */
        removeItem(vItem: number | string | sap.ui.unified.CalendarLegendItem): sap.ui.unified.CalendarLegendItem;

        /**
         * Sets a new value for property <code>columnWidth</code>.Width of the columns created in which the
         * items are arranged.When called with a value of <code>null</code> or <code>undefined</code>, the
         * default value of the property will be restored.Default value is <code>120px</code>.
         * @param sColumnWidth New value for property <code>columnWidth</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setColumnWidth(sColumnWidth: any): sap.ui.unified.CalendarLegend;
      }
      /**
       * Provides a main content and a secondary content area
       * @resource sap/ui/unified/SplitContainer.js
      */
      export class SplitContainer extends sap.ui.core.Control {


        /**
         * Constructor for a new SplitContainer.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Adds some content to the aggregation <code>content</code>.
         * @param oContent the content to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addContent(oContent: sap.ui.core.Control): sap.ui.unified.SplitContainer;

        /**
         * Adds some secondaryContent to the aggregation <code>secondaryContent</code>.
         * @param oSecondaryContent the secondaryContent to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addSecondaryContent(oSecondaryContent: sap.ui.core.Control): sap.ui.unified.SplitContainer;

        /**
         * Destroys all the content in the aggregation <code>content</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyContent(): sap.ui.unified.SplitContainer;

        /**
         * Destroys all the secondaryContent in the aggregation <code>secondaryContent</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroySecondaryContent(): sap.ui.unified.SplitContainer;


        /**
         * Gets content of aggregation <code>content</code>.The content to appear in the main area.
        */
        getContent(): sap.ui.core.Control[];

        /**
         * Returns a metadata object for class sap.ui.unified.SplitContainer.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>orientation</code>.Whether to show the secondary content on the
         * left ("Horizontal", default) or on the top ("Vertical").Default value is <code>Horizontal</code>.
         * @since 1.22.0
         * @returns Value of property <code>orientation</code>
        */
        getOrientation(): sap.ui.core.Orientation;

        /**
         * Gets content of aggregation <code>secondaryContent</code>.The content to appear in the secondary
         * area.
        */
        getSecondaryContent(): sap.ui.core.Control[];

        /**
         * Gets current value of property <code>secondaryContentSize</code>.The width if the secondary content.
         * The height is always 100%.Default value is <code>250px</code>.
         * @returns Value of property <code>secondaryContentSize</code>
        */
        getSecondaryContentSize(): any;

        /**
         * Gets current value of property <code>secondaryContentWidth</code>.Do not use. Use
         * secondaryContentSize instead.Default value is <code>250px</code>.
         * @returns Value of property <code>secondaryContentWidth</code>
        */
        getSecondaryContentWidth(): any;

        /**
         * Gets current value of property <code>showSecondaryContent</code>.Shows / Hides the secondary area.
         * @returns Value of property <code>showSecondaryContent</code>
        */
        getShowSecondaryContent(): boolean;

        /**
         * Checks for the provided <code>sap.ui.core.Control</code> in the aggregation <code>content</code>.and
         * returns its index if found or -1 otherwise.
         * @param oContent The content whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfContent(oContent: sap.ui.core.Control): number;

        /**
         * Checks for the provided <code>sap.ui.core.Control</code> in the aggregation
         * <code>secondaryContent</code>.and returns its index if found or -1 otherwise.
         * @param oSecondaryContent The secondaryContent whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfSecondaryContent(oSecondaryContent: sap.ui.core.Control): number;

        /**
         * Inserts a content into the aggregation <code>content</code>.
         * @param oContent the content to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the content should be inserted at; for             a
         * negative value of <code>iIndex</code>, the content is inserted at position 0; for a value           
         *  greater than the current size of the aggregation, the content is inserted at             the last
         * position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertContent(oContent: sap.ui.core.Control, iIndex: number): sap.ui.unified.SplitContainer;

        /**
         * Inserts a secondaryContent into the aggregation <code>secondaryContent</code>.
         * @param oSecondaryContent the secondaryContent to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the secondaryContent should be inserted at; for        
         *     a negative value of <code>iIndex</code>, the secondaryContent is inserted at position 0; for a
         * value             greater than the current size of the aggregation, the secondaryContent is inserted
         * at             the last position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertSecondaryContent(oSecondaryContent: sap.ui.core.Control, iIndex: number): sap.ui.unified.SplitContainer;

        /**
         * Removes all the controls from the aggregation <code>content</code>.Additionally, it unregisters them
         * from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllContent(): sap.ui.core.Control[];

        /**
         * Removes all the controls from the aggregation <code>secondaryContent</code>.Additionally, it
         * unregisters them from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllSecondaryContent(): sap.ui.core.Control[];

        /**
         * Removes a content from the aggregation <code>content</code>.
         * @param vContent The content to remove or its index or id
         * @returns The removed content or <code>null</code>
        */
        removeContent(vContent: number | string | sap.ui.core.Control): sap.ui.core.Control;

        /**
         * Removes a secondaryContent from the aggregation <code>secondaryContent</code>.
         * @param vSecondaryContent The secondaryContent to remove or its index or id
         * @returns The removed secondaryContent or <code>null</code>
        */
        removeSecondaryContent(vSecondaryContent: number | string | sap.ui.core.Control): sap.ui.core.Control;

        /**
         * Sets a new value for property <code>orientation</code>.Whether to show the secondary content on the
         * left ("Horizontal", default) or on the top ("Vertical").When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>Horizontal</code>.
         * @since 1.22.0
         * @param sOrientation New value for property <code>orientation</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setOrientation(sOrientation: sap.ui.core.Orientation): sap.ui.unified.SplitContainer;

        /**
         * Sets a new value for property <code>secondaryContentSize</code>.The width if the secondary content.
         * The height is always 100%.When called with a value of <code>null</code> or <code>undefined</code>,
         * the default value of the property will be restored.Default value is <code>250px</code>.
         * @param sSecondaryContentSize New value for property <code>secondaryContentSize</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setSecondaryContentSize(sSecondaryContentSize: any): sap.ui.unified.SplitContainer;

        /**
         * Sets a new value for property <code>secondaryContentWidth</code>.Do not use. Use
         * secondaryContentSize instead.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.Default value is
         * <code>250px</code>.
         * @param sSecondaryContentWidth New value for property <code>secondaryContentWidth</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setSecondaryContentWidth(sSecondaryContentWidth: any): sap.ui.unified.SplitContainer;

        /**
         * Sets a new value for property <code>showSecondaryContent</code>.Shows / Hides the secondary
         * area.When called with a value of <code>null</code> or <code>undefined</code>, the default value of
         * the property will be restored.
         * @param bShowSecondaryContent New value for property <code>showSecondaryContent</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setShowSecondaryContent(bShowSecondaryContent: boolean): sap.ui.unified.SplitContainer;
      }
      /**
       * Switches between two control areas and animates it via CSS transitions
       * @resource sap/ui/unified/ContentSwitcher.js
      */
      export class ContentSwitcher extends sap.ui.core.Control {


        /**
         * Constructor for a new ContentSwitcher.Accepts an object literal <code>mSettings</code> that defines
         * initialproperty values, aggregated and associated objects as well as event handlers.See {@link
         * sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the settings
         * object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Adds some content1 to the aggregation <code>content1</code>.
         * @param oContent1 the content1 to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addContent1(oContent1: sap.ui.core.Control): sap.ui.unified.ContentSwitcher;

        /**
         * Adds some content2 to the aggregation <code>content2</code>.
         * @param oContent2 the content2 to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addContent2(oContent2: sap.ui.core.Control): sap.ui.unified.ContentSwitcher;

        /**
         * Destroys all the content1 in the aggregation <code>content1</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyContent1(): sap.ui.unified.ContentSwitcher;

        /**
         * Destroys all the content2 in the aggregation <code>content2</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroyContent2(): sap.ui.unified.ContentSwitcher;


        /**
         * Gets current value of property <code>activeContent</code>.The number of the currently active content
         * (1 or 2).Default value is <code>1</code>.
         * @returns Value of property <code>activeContent</code>
        */
        getActiveContent(): number;

        /**
         * Gets current value of property <code>animation</code>.Set the used animation when changing content.
         * This just sets a CSS-class named "sapUiUnifiedACSwitcherAnimation" + this value on the root element
         * of the control. The animation has to be implemented in CSS. This also enables applications to
         * implement their own animations via CSS by reacting to the parent class.See the types
         * sap.ui.unified.ContentSwitcherAnimation for default implementations.Default value is
         * <code>None</code>.
         * @returns Value of property <code>animation</code>
        */
        getAnimation(): string;

        /**
         * Gets content of aggregation <code>content1</code>.The controls that should be shown in the first
         * content
        */
        getContent1(): sap.ui.core.Control[];

        /**
         * Gets content of aggregation <code>content2</code>.The controls that should be shown in the second
         * content
        */
        getContent2(): sap.ui.core.Control[];

        /**
         * Returns a metadata object for class sap.ui.unified.ContentSwitcher.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Checks for the provided <code>sap.ui.core.Control</code> in the aggregation
         * <code>content1</code>.and returns its index if found or -1 otherwise.
         * @param oContent1 The content1 whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfContent1(oContent1: sap.ui.core.Control): number;

        /**
         * Checks for the provided <code>sap.ui.core.Control</code> in the aggregation
         * <code>content2</code>.and returns its index if found or -1 otherwise.
         * @param oContent2 The content2 whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfContent2(oContent2: sap.ui.core.Control): number;

        /**
         * Inserts a content1 into the aggregation <code>content1</code>.
         * @param oContent1 the content1 to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the content1 should be inserted at; for             a
         * negative value of <code>iIndex</code>, the content1 is inserted at position 0; for a value          
         *   greater than the current size of the aggregation, the content1 is inserted at             the last
         * position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertContent1(oContent1: sap.ui.core.Control, iIndex: number): sap.ui.unified.ContentSwitcher;

        /**
         * Inserts a content2 into the aggregation <code>content2</code>.
         * @param oContent2 the content2 to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the content2 should be inserted at; for             a
         * negative value of <code>iIndex</code>, the content2 is inserted at position 0; for a value          
         *   greater than the current size of the aggregation, the content2 is inserted at             the last
         * position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertContent2(oContent2: sap.ui.core.Control, iIndex: number): sap.ui.unified.ContentSwitcher;

        /**
         * Removes all the controls from the aggregation <code>content1</code>.Additionally, it unregisters
         * them from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllContent1(): sap.ui.core.Control[];

        /**
         * Removes all the controls from the aggregation <code>content2</code>.Additionally, it unregisters
         * them from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllContent2(): sap.ui.core.Control[];

        /**
         * Removes a content1 from the aggregation <code>content1</code>.
         * @param vContent1 The content1 to remove or its index or id
         * @returns The removed content1 or <code>null</code>
        */
        removeContent1(vContent1: number | string | sap.ui.core.Control): sap.ui.core.Control;

        /**
         * Removes a content2 from the aggregation <code>content2</code>.
         * @param vContent2 The content2 to remove or its index or id
         * @returns The removed content2 or <code>null</code>
        */
        removeContent2(vContent2: number | string | sap.ui.core.Control): sap.ui.core.Control;

        /**
         * Sets a new value for property <code>activeContent</code>.The number of the currently active content
         * (1 or 2).When called with a value of <code>null</code> or <code>undefined</code>, the default value
         * of the property will be restored.Default value is <code>1</code>.
         * @param iActiveContent New value for property <code>activeContent</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setActiveContent(iActiveContent: number): sap.ui.unified.ContentSwitcher;

        /**
         * Sets a new value for property <code>animation</code>.Set the used animation when changing content.
         * This just sets a CSS-class named "sapUiUnifiedACSwitcherAnimation" + this value on the root element
         * of the control. The animation has to be implemented in CSS. This also enables applications to
         * implement their own animations via CSS by reacting to the parent class.See the types
         * sap.ui.unified.ContentSwitcherAnimation for default implementations.When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>None</code>.
         * @param sAnimation New value for property <code>animation</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setAnimation(sAnimation: string): sap.ui.unified.ContentSwitcher;

        /**
         * Changes the currently active content to the other one. If content 1 is active, content 2 willbe
         * activated and the other way around.
        */
        switchContent(): void;
      }
      /**
       * User Header Action Item of the Shell.
       * @resource sap/ui/unified/ShellHeadUserItem.js
      */
      export class ShellHeadUserItem extends sap.ui.core.Element {


        /**
         * Constructor for a new ShellHeadUserItem.Accepts an object literal <code>mSettings</code> that
         * defines initialproperty values, aggregated and associated objects as well as event handlers.See
         * {@link sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the
         * settings object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Adds some ariaLabelledBy into the association <code>ariaLabelledBy</code>.
         * @param vAriaLabelledBy the ariaLabelledBy to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addAriaLabelledBy(vAriaLabelledBy: any | sap.ui.core.Control): sap.ui.unified.ShellHeadUserItem;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>press</code> event of this
         * <code>sap.ui.unified.ShellHeadUserItem</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.unified.ShellHeadUserItem</code> itself.Event is fired when the user presses
         * the button.
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.unified.ShellHeadUserItem</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachPress(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.ShellHeadUserItem;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>press</code> event of this
         * <code>sap.ui.unified.ShellHeadUserItem</code>.The passed function and listener object must match the
         * ones used for event registration.
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachPress(fnFunction: any, oListener: any): sap.ui.unified.ShellHeadUserItem;


        /**
         * Fires event <code>press</code> to attached listeners.
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        firePress(mArguments: any): sap.ui.unified.ShellHeadUserItem;

        /**
         * Returns array of IDs of the elements which are the current targets of the association
         * <code>ariaLabelledBy</code>.
        */
        getAriaLabelledBy(): any[];

        /**
         * Gets current value of property <code>image</code>.An image of the user, normally an URI to a image
         * but also an icon from the sap.ui.core.IconPool is possible.
         * @returns Value of property <code>image</code>
        */
        getImage(): any;

        /**
         * Returns a metadata object for class sap.ui.unified.ShellHeadUserItem.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>showPopupIndicator</code>.The user item is intended to be used
         * for user settings. Normally these settings are done via a Menu or Dialog.If this property is set to
         * true an indicator for such a popup mechanismn is shown in the item.Default value is
         * <code>true</code>.
         * @since 1.27.0
         * @returns Value of property <code>showPopupIndicator</code>
        */
        getShowPopupIndicator(): boolean;

        /**
         * Gets current value of property <code>username</code>.The name of the user.Default value is
         * <code></code>.
         * @returns Value of property <code>username</code>
        */
        getUsername(): string;

        /**
         * Removes all the controls in the association named <code>ariaLabelledBy</code>.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllAriaLabelledBy(): any[];

        /**
         * Removes an ariaLabelledBy from the association named <code>ariaLabelledBy</code>.
         * @param vAriaLabelledBy The ariaLabelledBy to be removed or its index or ID
         * @returns The removed ariaLabelledBy or <code>null</code>
        */
        removeAriaLabelledBy(vAriaLabelledBy: number | any | sap.ui.core.Control): any;

        /**
         * Sets a new value for property <code>image</code>.An image of the user, normally an URI to a image
         * but also an icon from the sap.ui.core.IconPool is possible.When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
         * @param sImage New value for property <code>image</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setImage(sImage: any): sap.ui.unified.ShellHeadUserItem;

        /**
         * Sets a new value for property <code>showPopupIndicator</code>.The user item is intended to be used
         * for user settings. Normally these settings are done via a Menu or Dialog.If this property is set to
         * true an indicator for such a popup mechanismn is shown in the item.When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>true</code>.
         * @since 1.27.0
         * @param bShowPopupIndicator New value for property <code>showPopupIndicator</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setShowPopupIndicator(bShowPopupIndicator: boolean): sap.ui.unified.ShellHeadUserItem;

        /**
         * Sets a new value for property <code>username</code>.The name of the user.When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code></code>.
         * @param sUsername New value for property <code>username</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setUsername(sUsername: string): sap.ui.unified.ShellHeadUserItem;
      }
      /**
       * Special menu item which contains a label and a text field. This menu item is e.g. helpful for filter
       * implementations.The aggregation <code>submenu</code> (inherited from parent class) is not supported
       * for this type of menu item.
       * @resource sap/ui/unified/MenuTextFieldItem.js
      */
      export class MenuTextFieldItem extends sap.ui.unified.MenuItemBase {


        /**
         * Constructor for a new MenuTextFieldItem element.Accepts an object literal <code>mSettings</code>
         * that defines initialproperty values, aggregated and associated objects as well as event handlers.See
         * {@link sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the
         * settings object.
         * @param sId Id for the new control, generated automatically if no id is given
         * @param mSettings Initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * The aggregation <code>submenu</code> (inherited from parent class) is not supported for this type of
         * menu item.
         * @returns <code>this</code> to allow method chaining
        */
        destroySubmenu(): sap.ui.unified.MenuTextFieldItem;


        /**
         * Gets current value of property <code>icon</code>.Defines the icon of the {@link sap.ui.core.IconPool
         * sap.ui.core.IconPool} or an image which should be displayed on the item.
         * @returns Value of property <code>icon</code>
        */
        getIcon(): any;

        /**
         * Gets current value of property <code>label</code>.Defines the label of the text field of the item.
         * @returns Value of property <code>label</code>
        */
        getLabel(): string;

        /**
         * Returns a metadata object for class sap.ui.unified.MenuTextFieldItem.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * The aggregation <code>submenu</code> (inherited from parent class) is not supported for this type of
         * menu item.
        */
        getSubmenu(): sap.ui.unified.Menu;

        /**
         * Gets current value of property <code>value</code>.Defines the value of the text field of the item.
         * @returns Value of property <code>value</code>
        */
        getValue(): string;

        /**
         * Gets current value of property <code>valueState</code>.Defines the value state of the text field of
         * the item. This allows you to visualize e.g. warnings or errors.Default value is <code>None</code>.
         * @returns Value of property <code>valueState</code>
        */
        getValueState(): sap.ui.core.ValueState;

        /**
         * Sets a new value for property <code>icon</code>.Defines the icon of the {@link sap.ui.core.IconPool
         * sap.ui.core.IconPool} or an image which should be displayed on the item.When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
         * @param sIcon New value for property <code>icon</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setIcon(sIcon: any): sap.ui.unified.MenuTextFieldItem;

        /**
         * Sets a new value for property <code>label</code>.Defines the label of the text field of the
         * item.When called with a value of <code>null</code> or <code>undefined</code>, the default value of
         * the property will be restored.
         * @param sLabel New value for property <code>label</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setLabel(sLabel: string): sap.ui.unified.MenuTextFieldItem;

        /**
         * The aggregation <code>submenu</code> (inherited from parent class) is not supported for this type of
         * menu item.
         * @param oSubmenu undefined
         * @returns <code>this</code> to allow method chaining
        */
        setSubmenu(oSubmenu: sap.ui.unified.Menu): sap.ui.unified.MenuTextFieldItem;

        /**
         * Sets a new value for property <code>value</code>.Defines the value of the text field of the
         * item.When called with a value of <code>null</code> or <code>undefined</code>, the default value of
         * the property will be restored.
         * @param sValue New value for property <code>value</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setValue(sValue: string): sap.ui.unified.MenuTextFieldItem;

        /**
         * Sets a new value for property <code>valueState</code>.Defines the value state of the text field of
         * the item. This allows you to visualize e.g. warnings or errors.When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>None</code>.
         * @param sValueState New value for property <code>valueState</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setValueState(sValueState: sap.ui.core.ValueState): sap.ui.unified.MenuTextFieldItem;
      }
      /**
       * Item to be displayed in a CalendarLegend.
       * @resource sap/ui/unified/CalendarLegendItem.js
      */
      export class CalendarLegendItem extends sap.ui.core.Element {


        /**
         * Constructor for a new CalendarLegendItem.Accepts an object literal <code>mSettings</code> that
         * defines initialproperty values, aggregated and associated objects as well as event handlers.See
         * {@link sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the
         * settings object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);




        /**
         * Returns a metadata object for class sap.ui.unified.CalendarLegendItem.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>text</code>.Text to be displayed for the item.
         * @returns Value of property <code>text</code>
        */
        getText(): string;

        /**
         * Gets current value of property <code>type</code>.Type of the item.If not set the type is
         * automatically determined from the order of the items in the CalendarLegend.Default value is
         * <code>None</code>.
         * @since 1.28.9
         * @returns Value of property <code>type</code>
        */
        getType(): sap.ui.unified.CalendarDayType;

        /**
         * Sets a new value for property <code>text</code>.Text to be displayed for the item.When called with a
         * value of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.
         * @param sText New value for property <code>text</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setText(sText: string): sap.ui.unified.CalendarLegendItem;

        /**
         * Sets a new value for property <code>type</code>.Type of the item.If not set the type is
         * automatically determined from the order of the items in the CalendarLegend.When called with a value
         * of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>None</code>.
         * @since 1.28.9
         * @param sType New value for property <code>type</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setType(sType: sap.ui.unified.CalendarDayType): sap.ui.unified.CalendarLegendItem;
      }
      /**
       * An appointment for use in a <code>PlanningCalendar</code> or similar. The rendering must be done in
       * the Row collecting the appointments.(Because there are different visualizations
       * possible.)Applications could inherit from this element to add own fields.
       * @resource sap/ui/unified/CalendarAppointment.js
      */
      export class CalendarAppointment extends sap.ui.unified.DateTypeRange {


        /**
         * Constructor for a new <code>CalendarAppointment</code>.Accepts an object literal
         * <code>mSettings</code> that defines initialproperty values, aggregated and associated objects as
         * well as event handlers.See {@link sap.ui.base.ManagedObject#constructor} for a general description
         * of the syntax of the settings object.
         * @param sId ID for the new control, generated automatically if no ID is given
         * @param mSettings Initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);




        /**
         * Gets current value of property <code>icon</code>.Icon of the Appointment. (e.g. picture of the
         * person)URI of an image or an icon registered in sap.ui.core.IconPool.
         * @returns Value of property <code>icon</code>
        */
        getIcon(): any;

        /**
         * Gets current value of property <code>key</code>.Can be used as identifier of the appointment
         * @returns Value of property <code>key</code>
        */
        getKey(): string;

        /**
         * Returns a metadata object for class sap.ui.unified.CalendarAppointment.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>selected</code>.Indicates if the icon is selected.Default value
         * is <code>false</code>.
         * @returns Value of property <code>selected</code>
        */
        getSelected(): boolean;

        /**
         * Gets current value of property <code>tentative</code>.Indicates if the icon is tentative.Default
         * value is <code>false</code>.
         * @returns Value of property <code>tentative</code>
        */
        getTentative(): boolean;

        /**
         * Gets current value of property <code>text</code>.Text of the appointment.
         * @returns Value of property <code>text</code>
        */
        getText(): string;

        /**
         * Gets current value of property <code>title</code>.Title of the appointment.
         * @returns Value of property <code>title</code>
        */
        getTitle(): string;

        /**
         * Sets a new value for property <code>icon</code>.Icon of the Appointment. (e.g. picture of the
         * person)URI of an image or an icon registered in sap.ui.core.IconPool.When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
         * @param sIcon New value for property <code>icon</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setIcon(sIcon: any): sap.ui.unified.CalendarAppointment;

        /**
         * Sets a new value for property <code>key</code>.Can be used as identifier of the appointmentWhen
         * called with a value of <code>null</code> or <code>undefined</code>, the default value of the
         * property will be restored.
         * @param sKey New value for property <code>key</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setKey(sKey: string): sap.ui.unified.CalendarAppointment;

        /**
         * Sets a new value for property <code>selected</code>.Indicates if the icon is selected.When called
         * with a value of <code>null</code> or <code>undefined</code>, the default value of the property will
         * be restored.Default value is <code>false</code>.
         * @param bSelected New value for property <code>selected</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setSelected(bSelected: boolean): sap.ui.unified.CalendarAppointment;

        /**
         * Sets a new value for property <code>tentative</code>.Indicates if the icon is tentative.When called
         * with a value of <code>null</code> or <code>undefined</code>, the default value of the property will
         * be restored.Default value is <code>false</code>.
         * @param bTentative New value for property <code>tentative</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setTentative(bTentative: boolean): sap.ui.unified.CalendarAppointment;

        /**
         * Sets a new value for property <code>text</code>.Text of the appointment.When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
         * @param sText New value for property <code>text</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setText(sText: string): sap.ui.unified.CalendarAppointment;

        /**
         * Sets a new value for property <code>title</code>.Title of the appointment.When called with a value
         * of <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
         * @param sTitle New value for property <code>title</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setTitle(sTitle: string): sap.ui.unified.CalendarAppointment;
      }
      /**
       * Calendar with granularity of time items displayed in one line.
       * @resource sap/ui/unified/CalendarTimeInterval.js
      */
      export class CalendarTimeInterval extends sap.ui.core.Control {


        /**
         * Constructor for a new <code>CalendarTimeInterval</code>.Accepts an object literal
         * <code>mSettings</code> that defines initialproperty values, aggregated and associated objects as
         * well as event handlers.See {@link sap.ui.base.ManagedObject#constructor} for a general description
         * of the syntax of the settings object.
         * @param sId ID for the new control, generated automatically if no ID is given
         * @param mSettings Initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Adds some ariaLabelledBy into the association <code>ariaLabelledBy</code>.
         * @param vAriaLabelledBy the ariaLabelledBy to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addAriaLabelledBy(vAriaLabelledBy: any | sap.ui.core.Control): sap.ui.unified.CalendarTimeInterval;

        /**
         * Adds some selectedDate to the aggregation <code>selectedDates</code>.
         * @param oSelectedDate the selectedDate to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addSelectedDate(oSelectedDate: sap.ui.unified.DateRange): sap.ui.unified.CalendarTimeInterval;

        /**
         * Adds some specialDate to the aggregation <code>specialDates</code>.
         * @param oSpecialDate the specialDate to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addSpecialDate(oSpecialDate: sap.ui.unified.DateTypeRange): sap.ui.unified.CalendarTimeInterval;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>cancel</code> event of this
         * <code>sap.ui.unified.CalendarTimeInterval</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.unified.CalendarTimeInterval</code> itself.Time selection was cancelled
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.unified.CalendarTimeInterval</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachCancel(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.CalendarTimeInterval;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>select</code> event of this
         * <code>sap.ui.unified.CalendarTimeInterval</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.unified.CalendarTimeInterval</code> itself.Time selection changed
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.unified.CalendarTimeInterval</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachSelect(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.CalendarTimeInterval;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>startDateChange</code> event of this
         * <code>sap.ui.unified.CalendarTimeInterval</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.unified.CalendarTimeInterval</code> itself.<code>startDate</code> was changed
         * while navigation in <code>CalendarTimeInterval</code>
         * @since 1.34.0
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.unified.CalendarTimeInterval</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachStartDateChange(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.CalendarTimeInterval;

        /**
         * Destroys all the selectedDates in the aggregation <code>selectedDates</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroySelectedDates(): sap.ui.unified.CalendarTimeInterval;

        /**
         * Destroys all the specialDates in the aggregation <code>specialDates</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroySpecialDates(): sap.ui.unified.CalendarTimeInterval;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>cancel</code> event of this
         * <code>sap.ui.unified.CalendarTimeInterval</code>.The passed function and listener object must match
         * the ones used for event registration.
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachCancel(fnFunction: any, oListener: any): sap.ui.unified.CalendarTimeInterval;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>select</code> event of this
         * <code>sap.ui.unified.CalendarTimeInterval</code>.The passed function and listener object must match
         * the ones used for event registration.
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachSelect(fnFunction: any, oListener: any): sap.ui.unified.CalendarTimeInterval;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>startDateChange</code> event of this
         * <code>sap.ui.unified.CalendarTimeInterval</code>.The passed function and listener object must match
         * the ones used for event registration.
         * @since 1.34.0
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachStartDateChange(fnFunction: any, oListener: any): sap.ui.unified.CalendarTimeInterval;

        /**
         * Displays a item in the <code>CalendarTimeInterval</code> but doesn't set the focus.
         * @param oDate JavaScript date object for displayed item.
         * @returns <code>this</code> to allow method chaining
        */
        displayDate(oDate: any): typeof sap.ui.unified.Calendar;


        /**
         * Fires event <code>cancel</code> to attached listeners.
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireCancel(mArguments: any): sap.ui.unified.CalendarTimeInterval;

        /**
         * Fires event <code>select</code> to attached listeners.
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireSelect(mArguments: any): sap.ui.unified.CalendarTimeInterval;

        /**
         * Fires event <code>startDateChange</code> to attached listeners.
         * @since 1.34.0
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireStartDateChange(mArguments: any): sap.ui.unified.CalendarTimeInterval;

        /**
         * Sets the focused item of the <code>CalendarTimeInterval</code>.
         * @param oDate JavaScript date object for focused item.
         * @returns <code>this</code> to allow method chaining
        */
        focusDate(oDate: any): typeof sap.ui.unified.Calendar;

        /**
         * Returns array of IDs of the elements which are the current targets of the association
         * <code>ariaLabelledBy</code>.
        */
        getAriaLabelledBy(): any[];

        /**
         * Gets current value of property <code>intervalMinutes</code>.Size of on time interval in minutes,
         * default is 60 minutes.<b>Note:</b> the start of the interval calculation is always on the
         * corresponding date at 00:00.A interval longer then 720 minutes is not allowed. Please use the
         * <code>CalendarDateInterval</code> instead.A day must be divisible by this interval size. One
         * interval must not include more than one day.Default value is <code>60</code>.
         * @returns Value of property <code>intervalMinutes</code>
        */
        getIntervalMinutes(): number;

        /**
         * Gets current value of property <code>intervalSelection</code>.If set, interval selection is
         * allowedDefault value is <code>false</code>.
         * @returns Value of property <code>intervalSelection</code>
        */
        getIntervalSelection(): boolean;

        /**
         * Gets current value of property <code>items</code>.Number of time items displayed. Default is
         * 12.<b>Note:</b> On phones, the maximum number of items displayed in the row is always 6.Default
         * value is <code>12</code>.
         * @returns Value of property <code>items</code>
        */
        getItems(): number;

        /**
         * ID of the element which is the current target of the association <code>legend</code>, or
         * <code>null</code>.
         * @since 1.38.5
        */
        getLegend(): any;

        /**
         * Gets current value of property <code>maxDate</code>.Maximum date that can be shown and selected in
         * the Calendar. This must be a JavaScript date object.<b>Note:</b> If the <code>maxDate</code> is set
         * to be before the <code>minDate</code>,the <code>minDate</code> is set to the begin of the month of
         * the <code>maxDate</code>.
         * @since 1.38.0
         * @returns Value of property <code>maxDate</code>
        */
        getMaxDate(): any;

        /**
         * Returns a metadata object for class sap.ui.unified.CalendarTimeInterval.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>minDate</code>.Minimum date that can be shown and selected in
         * the Calendar. This must be a JavaScript date object.<b>Note:</b> If the <code>minDate</code> is set
         * to be after the <code>maxDate</code>,the <code>maxDate</code> is set to the end of the month of the
         * <code>minDate</code>.
         * @since 1.38.0
         * @returns Value of property <code>minDate</code>
        */
        getMinDate(): any;

        /**
         * Gets current value of property <code>pickerPopup</code>.If set, the day-, month- and yearPicker
         * opens on a popupDefault value is <code>false</code>.
         * @since 1.34.0
         * @returns Value of property <code>pickerPopup</code>
        */
        getPickerPopup(): boolean;

        /**
         * Gets content of aggregation <code>selectedDates</code>.Date ranges for selected items of the
         * <code>CalendarTimeInterval</code>.If <code>singleSelection</code> is set, only the first entry is
         * used.
        */
        getSelectedDates(): sap.ui.unified.DateRange[];

        /**
         * Gets current value of property <code>singleSelection</code>.If set, only a single date or interval,
         * if <code>intervalSelection</code> is enabled, can be selected<b>Note:</b> Selection of multiple
         * intervals is not supported in the current version.Default value is <code>true</code>.
         * @returns Value of property <code>singleSelection</code>
        */
        getSingleSelection(): boolean;

        /**
         * Gets content of aggregation <code>specialDates</code>.Date ranges with type to visualize special
         * items in the <code>CalendarTimeInterval</code>.If one interval is assigned to more than one type,
         * only the first one will be used.
        */
        getSpecialDates(): sap.ui.unified.DateTypeRange[];

        /**
         * Gets current value of property <code>startDate</code>.Start date of the Interval as JavaScript Date
         * object.The time interval corresponding to this Date and <code>items</code> and
         * <code>intervalMinutes</code>will be the first time in the displayed row.
         * @returns Value of property <code>startDate</code>
        */
        getStartDate(): any;

        /**
         * Gets current value of property <code>width</code>.Width of the <code>CalendarTimeInterval</code>.
         * The width of the single months depends on this width.
         * @returns Value of property <code>width</code>
        */
        getWidth(): any;

        /**
         * Checks for the provided <code>sap.ui.unified.DateRange</code> in the aggregation
         * <code>selectedDates</code>.and returns its index if found or -1 otherwise.
         * @param oSelectedDate The selectedDate whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfSelectedDate(oSelectedDate: sap.ui.unified.DateRange): number;

        /**
         * Checks for the provided <code>sap.ui.unified.DateTypeRange</code> in the aggregation
         * <code>specialDates</code>.and returns its index if found or -1 otherwise.
         * @param oSpecialDate The specialDate whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfSpecialDate(oSpecialDate: sap.ui.unified.DateTypeRange): number;

        /**
         * Inserts a selectedDate into the aggregation <code>selectedDates</code>.
         * @param oSelectedDate the selectedDate to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the selectedDate should be inserted at; for            
         * a negative value of <code>iIndex</code>, the selectedDate is inserted at position 0; for a value    
         *         greater than the current size of the aggregation, the selectedDate is inserted at           
         *  the last position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertSelectedDate(oSelectedDate: sap.ui.unified.DateRange, iIndex: number): sap.ui.unified.CalendarTimeInterval;

        /**
         * Inserts a specialDate into the aggregation <code>specialDates</code>.
         * @param oSpecialDate the specialDate to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the specialDate should be inserted at; for            
         * a negative value of <code>iIndex</code>, the specialDate is inserted at position 0; for a value     
         *        greater than the current size of the aggregation, the specialDate is inserted at            
         * the last position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertSpecialDate(oSpecialDate: sap.ui.unified.DateTypeRange, iIndex: number): sap.ui.unified.CalendarTimeInterval;

        /**
         * Removes all the controls in the association named <code>ariaLabelledBy</code>.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllAriaLabelledBy(): any[];

        /**
         * Removes all the controls from the aggregation <code>selectedDates</code>.Additionally, it
         * unregisters them from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllSelectedDates(): sap.ui.unified.DateRange[];

        /**
         * Removes all the controls from the aggregation <code>specialDates</code>.Additionally, it unregisters
         * them from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllSpecialDates(): sap.ui.unified.DateTypeRange[];

        /**
         * Removes an ariaLabelledBy from the association named <code>ariaLabelledBy</code>.
         * @param vAriaLabelledBy The ariaLabelledBy to be removed or its index or ID
         * @returns The removed ariaLabelledBy or <code>null</code>
        */
        removeAriaLabelledBy(vAriaLabelledBy: number | any | sap.ui.core.Control): any;

        /**
         * Removes a selectedDate from the aggregation <code>selectedDates</code>.
         * @param vSelectedDate The selectedDate to remove or its index or id
         * @returns The removed selectedDate or <code>null</code>
        */
        removeSelectedDate(vSelectedDate: number | string | sap.ui.unified.DateRange): sap.ui.unified.DateRange;

        /**
         * Removes a specialDate from the aggregation <code>specialDates</code>.
         * @param vSpecialDate The specialDate to remove or its index or id
         * @returns The removed specialDate or <code>null</code>
        */
        removeSpecialDate(vSpecialDate: number | string | sap.ui.unified.DateTypeRange): sap.ui.unified.DateTypeRange;

        /**
         * Sets a new value for property <code>intervalMinutes</code>.Size of on time interval in minutes,
         * default is 60 minutes.<b>Note:</b> the start of the interval calculation is always on the
         * corresponding date at 00:00.A interval longer then 720 minutes is not allowed. Please use the
         * <code>CalendarDateInterval</code> instead.A day must be divisible by this interval size. One
         * interval must not include more than one day.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.Default value is
         * <code>60</code>.
         * @param iIntervalMinutes New value for property <code>intervalMinutes</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setIntervalMinutes(iIntervalMinutes: number): sap.ui.unified.CalendarTimeInterval;

        /**
         * Sets a new value for property <code>intervalSelection</code>.If set, interval selection is
         * allowedWhen called with a value of <code>null</code> or <code>undefined</code>, the default value of
         * the property will be restored.Default value is <code>false</code>.
         * @param bIntervalSelection New value for property <code>intervalSelection</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setIntervalSelection(bIntervalSelection: boolean): sap.ui.unified.CalendarTimeInterval;

        /**
         * Sets a new value for property <code>items</code>.Number of time items displayed. Default is
         * 12.<b>Note:</b> On phones, the maximum number of items displayed in the row is always 6.When called
         * with a value of <code>null</code> or <code>undefined</code>, the default value of the property will
         * be restored.Default value is <code>12</code>.
         * @param iItems New value for property <code>items</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setItems(iItems: number): sap.ui.unified.CalendarTimeInterval;

        /**
         * Sets the associated <code>legend</code>.
         * @since 1.38.5
         * @param oLegend ID of an element which becomes the new target of this legend association;
         * alternatively, an element instance may be given
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setLegend(oLegend: any | sap.ui.unified.CalendarLegend): sap.ui.unified.CalendarTimeInterval;

        /**
         * Sets a new value for property <code>maxDate</code>.Maximum date that can be shown and selected in
         * the Calendar. This must be a JavaScript date object.<b>Note:</b> If the <code>maxDate</code> is set
         * to be before the <code>minDate</code>,the <code>minDate</code> is set to the begin of the month of
         * the <code>maxDate</code>.When called with a value of <code>null</code> or <code>undefined</code>,
         * the default value of the property will be restored.
         * @since 1.38.0
         * @param oMaxDate New value for property <code>maxDate</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setMaxDate(oMaxDate: any): sap.ui.unified.CalendarTimeInterval;

        /**
         * Sets a new value for property <code>minDate</code>.Minimum date that can be shown and selected in
         * the Calendar. This must be a JavaScript date object.<b>Note:</b> If the <code>minDate</code> is set
         * to be after the <code>maxDate</code>,the <code>maxDate</code> is set to the end of the month of the
         * <code>minDate</code>.When called with a value of <code>null</code> or <code>undefined</code>, the
         * default value of the property will be restored.
         * @since 1.38.0
         * @param oMinDate New value for property <code>minDate</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setMinDate(oMinDate: any): sap.ui.unified.CalendarTimeInterval;

        /**
         * Sets a new value for property <code>pickerPopup</code>.If set, the day-, month- and yearPicker opens
         * on a popupWhen called with a value of <code>null</code> or <code>undefined</code>, the default value
         * of the property will be restored.Default value is <code>false</code>.
         * @since 1.34.0
         * @param bPickerPopup New value for property <code>pickerPopup</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setPickerPopup(bPickerPopup: boolean): sap.ui.unified.CalendarTimeInterval;

        /**
         * Sets a new value for property <code>singleSelection</code>.If set, only a single date or interval,
         * if <code>intervalSelection</code> is enabled, can be selected<b>Note:</b> Selection of multiple
         * intervals is not supported in the current version.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.Default value is
         * <code>true</code>.
         * @param bSingleSelection New value for property <code>singleSelection</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setSingleSelection(bSingleSelection: boolean): sap.ui.unified.CalendarTimeInterval;

        /**
         * Sets a new value for property <code>startDate</code>.Start date of the Interval as JavaScript Date
         * object.The time interval corresponding to this Date and <code>items</code> and
         * <code>intervalMinutes</code>will be the first time in the displayed row.When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
         * @param oStartDate New value for property <code>startDate</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setStartDate(oStartDate: any): sap.ui.unified.CalendarTimeInterval;

        /**
         * Sets a new value for property <code>width</code>.Width of the <code>CalendarTimeInterval</code>. The
         * width of the single months depends on this width.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.
         * @param sWidth New value for property <code>width</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setWidth(sWidth: any): sap.ui.unified.CalendarTimeInterval;
      }
      /**
       * Calendar with dates displayed in one line.
       * @resource sap/ui/unified/CalendarDateInterval.js
      */
      export class CalendarDateInterval extends sap.ui.unified.Calendar {


        /**
         * Constructor for a new <code>CalendarDateInterval</code>.Accepts an object literal
         * <code>mSettings</code> that defines initialproperty values, aggregated and associated objects as
         * well as event handlers.See {@link sap.ui.base.ManagedObject#constructor} for a general description
         * of the syntax of the settings object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);




        /**
         * Gets current value of property <code>days</code>.number of days displayedon phones the maximum
         * rendered number of days is 8.Default value is <code>7</code>.
         * @returns Value of property <code>days</code>
        */
        getDays(): number;

        /**
         * Returns a metadata object for class sap.ui.unified.CalendarDateInterval.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>pickerPopup</code>.If set, the month- and yearPicker opens on a
         * popupDefault value is <code>false</code>.
         * @since 1.34.0
         * @returns Value of property <code>pickerPopup</code>
        */
        getPickerPopup(): boolean;

        /**
         * Gets current value of property <code>showDayNamesLine</code>.If set the day names are shown in a
         * separate line.If not set the day names are shown inside the single days.Default value is
         * <code>true</code>.
         * @since 1.34.0
         * @returns Value of property <code>showDayNamesLine</code>
        */
        getShowDayNamesLine(): boolean;

        /**
         * Sets a new value for property <code>days</code>.number of days displayedon phones the maximum
         * rendered number of days is 8.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.Default value is
         * <code>7</code>.
         * @param iDays New value for property <code>days</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setDays(iDays: number): sap.ui.unified.CalendarDateInterval;

        /**
         * Setter for property <code>firstDayOfWeek</code>.Property <code>firstDayOfWeek</code> is not
         * supported in <code>sap.ui.unified.CalendarDateInterval</code> control.
         * @param iFirstDayOfWeek first day of the week
        */
        setFirstDayOfWeek(iFirstDayOfWeek: number): void;

        /**
         * Setter for property <code>months</code>.Property <code>months</code> is not supported in
         * <code>sap.ui.unified.CalendarDateInterval</code> control.
         * @param iMonths months
        */
        setMonths(iMonths: number): void;

        /**
         * Sets a new value for property <code>pickerPopup</code>.If set, the month- and yearPicker opens on a
         * popupWhen called with a value of <code>null</code> or <code>undefined</code>, the default value of
         * the property will be restored.Default value is <code>false</code>.
         * @since 1.34.0
         * @param bPickerPopup New value for property <code>pickerPopup</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setPickerPopup(bPickerPopup: boolean): sap.ui.unified.CalendarDateInterval;

        /**
         * Sets a new value for property <code>showDayNamesLine</code>.If set the day names are shown in a
         * separate line.If not set the day names are shown inside the single days.When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>true</code>.
         * @since 1.34.0
         * @param bShowDayNamesLine New value for property <code>showDayNamesLine</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setShowDayNamesLine(bShowDayNamesLine: boolean): sap.ui.unified.CalendarDateInterval;

        /**
         * Sets a new value for property <code>startDate</code>.Start date of the IntervalWhen called with a
         * value of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.
         * @param oStartDate New value for property <code>startDate</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setStartDate(oStartDate: any): sap.ui.unified.CalendarDateInterval;
      }
      /**
       * Calendar with granularity of months displayed in one line.<b>Note:</b> JavaScript Date objects are
       * used to set and return the months, mark them as selected or as a special type.But the date part of
       * the Date object is not used. If a Date object is returned the date will be set to the 1st of the
       * corresponding month.
       * @resource sap/ui/unified/CalendarMonthInterval.js
      */
      export class CalendarMonthInterval extends sap.ui.core.Control {


        /**
         * Constructor for a new <code>CalendarMonthInterval</code>.Accepts an object literal
         * <code>mSettings</code> that defines initialproperty values, aggregated and associated objects as
         * well as event handlers.See {@link sap.ui.base.ManagedObject#constructor} for a general description
         * of the syntax of the settings object.
         * @param sId ID for the new control, generated automatically if no ID is given
         * @param mSettings Initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);



        /**
         * Adds some ariaLabelledBy into the association <code>ariaLabelledBy</code>.
         * @param vAriaLabelledBy the ariaLabelledBy to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addAriaLabelledBy(vAriaLabelledBy: any | sap.ui.core.Control): sap.ui.unified.CalendarMonthInterval;

        /**
         * Adds some selectedDate to the aggregation <code>selectedDates</code>.
         * @param oSelectedDate the selectedDate to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addSelectedDate(oSelectedDate: sap.ui.unified.DateRange): sap.ui.unified.CalendarMonthInterval;

        /**
         * Adds some specialDate to the aggregation <code>specialDates</code>.
         * @param oSpecialDate the specialDate to add; if empty, nothing is inserted
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        addSpecialDate(oSpecialDate: sap.ui.unified.DateTypeRange): sap.ui.unified.CalendarMonthInterval;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>cancel</code> event of this
         * <code>sap.ui.unified.CalendarMonthInterval</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.unified.CalendarMonthInterval</code> itself.Month selection was cancelled
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.unified.CalendarMonthInterval</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachCancel(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.CalendarMonthInterval;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>select</code> event of this
         * <code>sap.ui.unified.CalendarMonthInterval</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.unified.CalendarMonthInterval</code> itself.Month selection changed
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.unified.CalendarMonthInterval</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachSelect(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.CalendarMonthInterval;

        /**
         * Attaches event handler <code>fnFunction</code> to the <code>startDateChange</code> event of this
         * <code>sap.ui.unified.CalendarMonthInterval</code>.When called, the context of the event handler (its
         * <code>this</code>) will be bound to <code>oListener</code> if specified, otherwise it will be bound
         * to this <code>sap.ui.unified.CalendarMonthInterval</code> itself.<code>startDate</code> was changed
         * while navigation in <code>CalendarMonthInterval</code>
         * @since 1.34.0
         * @param oData An application-specific payload object that will be passed to the event handler along
         * with the event object when firing the event
         * @param fnFunction The function to be called when the event occurs
         * @param oListener Context object to call the event handler with. Defaults to this
         * <code>sap.ui.unified.CalendarMonthInterval</code> itself
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        attachStartDateChange(oData: any, fnFunction: any, oListener?: any): sap.ui.unified.CalendarMonthInterval;

        /**
         * Destroys all the selectedDates in the aggregation <code>selectedDates</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroySelectedDates(): sap.ui.unified.CalendarMonthInterval;

        /**
         * Destroys all the specialDates in the aggregation <code>specialDates</code>.
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        destroySpecialDates(): sap.ui.unified.CalendarMonthInterval;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>cancel</code> event of this
         * <code>sap.ui.unified.CalendarMonthInterval</code>.The passed function and listener object must match
         * the ones used for event registration.
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachCancel(fnFunction: any, oListener: any): sap.ui.unified.CalendarMonthInterval;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>select</code> event of this
         * <code>sap.ui.unified.CalendarMonthInterval</code>.The passed function and listener object must match
         * the ones used for event registration.
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachSelect(fnFunction: any, oListener: any): sap.ui.unified.CalendarMonthInterval;

        /**
         * Detaches event handler <code>fnFunction</code> from the <code>startDateChange</code> event of this
         * <code>sap.ui.unified.CalendarMonthInterval</code>.The passed function and listener object must match
         * the ones used for event registration.
         * @since 1.34.0
         * @param fnFunction The function to be called, when the event occurs
         * @param oListener Context object on which the given function had to be called
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        detachStartDateChange(fnFunction: any, oListener: any): sap.ui.unified.CalendarMonthInterval;

        /**
         * Displays a month in the <code>CalendarMonthInterval</code> but doesn't set the focus.
         * @param oDate JavaScript date object for displayed date. (The month of this date will be displayed.)
         * @returns <code>this</code> to allow method chaining
        */
        displayDate(oDate: any): typeof sap.ui.unified.Calendar;


        /**
         * Fires event <code>cancel</code> to attached listeners.
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireCancel(mArguments: any): sap.ui.unified.CalendarMonthInterval;

        /**
         * Fires event <code>select</code> to attached listeners.
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireSelect(mArguments: any): sap.ui.unified.CalendarMonthInterval;

        /**
         * Fires event <code>startDateChange</code> to attached listeners.
         * @since 1.34.0
         * @param mArguments The arguments to pass along with the event
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        fireStartDateChange(mArguments: any): sap.ui.unified.CalendarMonthInterval;

        /**
         * Sets the focused month of the <code>CalendarMonthInterval</code>.
         * @param oDate JavaScript date object for focused date. (The month of this date will be focused.)
         * @returns <code>this</code> to allow method chaining
        */
        focusDate(oDate: any): typeof sap.ui.unified.Calendar;

        /**
         * Returns array of IDs of the elements which are the current targets of the association
         * <code>ariaLabelledBy</code>.
        */
        getAriaLabelledBy(): any[];

        /**
         * Gets current value of property <code>intervalSelection</code>.If set, interval selection is
         * allowedDefault value is <code>false</code>.
         * @returns Value of property <code>intervalSelection</code>
        */
        getIntervalSelection(): boolean;

        /**
         * ID of the element which is the current target of the association <code>legend</code>, or
         * <code>null</code>.
         * @since 1.38.5
        */
        getLegend(): any;

        /**
         * Gets current value of property <code>maxDate</code>.Maximum date that can be shown and selected in
         * the Calendar. This must be a JavaScript date object.<b>Note:</b> If the <code>maxDate</code> is set
         * to be before the <code>minDate</code>,the <code>minDate</code> is set to the begin of the month of
         * the <code>maxDate</code>.
         * @since 1.38.0
         * @returns Value of property <code>maxDate</code>
        */
        getMaxDate(): any;

        /**
         * Returns a metadata object for class sap.ui.unified.CalendarMonthInterval.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>minDate</code>.Minimum date that can be shown and selected in
         * the Calendar. This must be a JavaScript date object.<b>Note:</b> If the <code>minDate</code> is set
         * to be after the <code>maxDate</code>,the <code>maxDate</code> is set to the end of the month of the
         * <code>minDate</code>.
         * @since 1.38.0
         * @returns Value of property <code>minDate</code>
        */
        getMinDate(): any;

        /**
         * Gets current value of property <code>months</code>.Number of months displayed<b>Note:</b> On phones,
         * the maximum number of months displayed in the row is always 6.Default value is <code>12</code>.
         * @returns Value of property <code>months</code>
        */
        getMonths(): number;

        /**
         * Gets current value of property <code>pickerPopup</code>.If set, the yearPicker opens on a
         * popupDefault value is <code>false</code>.
         * @since 1.34.0
         * @returns Value of property <code>pickerPopup</code>
        */
        getPickerPopup(): boolean;

        /**
         * Gets content of aggregation <code>selectedDates</code>.Date ranges for selected dates of the
         * <code>CalendarMonthInterval</code>.If <code>singleSelection</code> is set, only the first entry is
         * used.<b>Note:</b> Even if only one day is selected, the whole corresponding month is selected.
        */
        getSelectedDates(): sap.ui.unified.DateRange[];

        /**
         * Gets current value of property <code>singleSelection</code>.If set, only a single date or interval,
         * if <code>intervalSelection</code> is enabled, can be selected<b>Note:</b> Selection of multiple
         * intervals is not supported in the current version.Default value is <code>true</code>.
         * @returns Value of property <code>singleSelection</code>
        */
        getSingleSelection(): boolean;

        /**
         * Gets content of aggregation <code>specialDates</code>.Date ranges with type to visualize special
         * months in the <code>CalendarMonthInterval</code>.If one day is assigned to more than one type, only
         * the first one will be used.<b>Note:</b> Even if only one day is set as a special day, the whole
         * corresponding month is displayed in this way.
        */
        getSpecialDates(): sap.ui.unified.DateTypeRange[];

        /**
         * Gets current value of property <code>startDate</code>.Start date of the Interval as JavaScript Date
         * object.The month of this Date will be the first month in the displayed row.
         * @returns Value of property <code>startDate</code>
        */
        getStartDate(): any;

        /**
         * Gets current value of property <code>width</code>.Width of the <code>CalendarMonthInterval</code>.
         * The width of the single months depends on this width.
         * @returns Value of property <code>width</code>
        */
        getWidth(): any;

        /**
         * Checks for the provided <code>sap.ui.unified.DateRange</code> in the aggregation
         * <code>selectedDates</code>.and returns its index if found or -1 otherwise.
         * @param oSelectedDate The selectedDate whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfSelectedDate(oSelectedDate: sap.ui.unified.DateRange): number;

        /**
         * Checks for the provided <code>sap.ui.unified.DateTypeRange</code> in the aggregation
         * <code>specialDates</code>.and returns its index if found or -1 otherwise.
         * @param oSpecialDate The specialDate whose index is looked for
         * @returns The index of the provided control in the aggregation if found, or -1 otherwise
        */
        indexOfSpecialDate(oSpecialDate: sap.ui.unified.DateTypeRange): number;

        /**
         * Inserts a selectedDate into the aggregation <code>selectedDates</code>.
         * @param oSelectedDate the selectedDate to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the selectedDate should be inserted at; for            
         * a negative value of <code>iIndex</code>, the selectedDate is inserted at position 0; for a value    
         *         greater than the current size of the aggregation, the selectedDate is inserted at           
         *  the last position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertSelectedDate(oSelectedDate: sap.ui.unified.DateRange, iIndex: number): sap.ui.unified.CalendarMonthInterval;

        /**
         * Inserts a specialDate into the aggregation <code>specialDates</code>.
         * @param oSpecialDate the specialDate to insert; if empty, nothing is inserted
         * @param iIndex the <code>0</code>-based index the specialDate should be inserted at; for            
         * a negative value of <code>iIndex</code>, the specialDate is inserted at position 0; for a value     
         *        greater than the current size of the aggregation, the specialDate is inserted at            
         * the last position
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        insertSpecialDate(oSpecialDate: sap.ui.unified.DateTypeRange, iIndex: number): sap.ui.unified.CalendarMonthInterval;

        /**
         * Removes all the controls in the association named <code>ariaLabelledBy</code>.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllAriaLabelledBy(): any[];

        /**
         * Removes all the controls from the aggregation <code>selectedDates</code>.Additionally, it
         * unregisters them from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllSelectedDates(): sap.ui.unified.DateRange[];

        /**
         * Removes all the controls from the aggregation <code>specialDates</code>.Additionally, it unregisters
         * them from the hosting UIArea.
         * @returns An array of the removed elements (might be empty)
        */
        removeAllSpecialDates(): sap.ui.unified.DateTypeRange[];

        /**
         * Removes an ariaLabelledBy from the association named <code>ariaLabelledBy</code>.
         * @param vAriaLabelledBy The ariaLabelledBy to be removed or its index or ID
         * @returns The removed ariaLabelledBy or <code>null</code>
        */
        removeAriaLabelledBy(vAriaLabelledBy: number | any | sap.ui.core.Control): any;

        /**
         * Removes a selectedDate from the aggregation <code>selectedDates</code>.
         * @param vSelectedDate The selectedDate to remove or its index or id
         * @returns The removed selectedDate or <code>null</code>
        */
        removeSelectedDate(vSelectedDate: number | string | sap.ui.unified.DateRange): sap.ui.unified.DateRange;

        /**
         * Removes a specialDate from the aggregation <code>specialDates</code>.
         * @param vSpecialDate The specialDate to remove or its index or id
         * @returns The removed specialDate or <code>null</code>
        */
        removeSpecialDate(vSpecialDate: number | string | sap.ui.unified.DateTypeRange): sap.ui.unified.DateTypeRange;

        /**
         * Sets a new value for property <code>intervalSelection</code>.If set, interval selection is
         * allowedWhen called with a value of <code>null</code> or <code>undefined</code>, the default value of
         * the property will be restored.Default value is <code>false</code>.
         * @param bIntervalSelection New value for property <code>intervalSelection</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setIntervalSelection(bIntervalSelection: boolean): sap.ui.unified.CalendarMonthInterval;

        /**
         * Sets the associated <code>legend</code>.
         * @since 1.38.5
         * @param oLegend ID of an element which becomes the new target of this legend association;
         * alternatively, an element instance may be given
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setLegend(oLegend: any | sap.ui.unified.CalendarLegend): sap.ui.unified.CalendarMonthInterval;

        /**
         * Sets a new value for property <code>maxDate</code>.Maximum date that can be shown and selected in
         * the Calendar. This must be a JavaScript date object.<b>Note:</b> If the <code>maxDate</code> is set
         * to be before the <code>minDate</code>,the <code>minDate</code> is set to the begin of the month of
         * the <code>maxDate</code>.When called with a value of <code>null</code> or <code>undefined</code>,
         * the default value of the property will be restored.
         * @since 1.38.0
         * @param oMaxDate New value for property <code>maxDate</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setMaxDate(oMaxDate: any): sap.ui.unified.CalendarMonthInterval;

        /**
         * Sets a new value for property <code>minDate</code>.Minimum date that can be shown and selected in
         * the Calendar. This must be a JavaScript date object.<b>Note:</b> If the <code>minDate</code> is set
         * to be after the <code>maxDate</code>,the <code>maxDate</code> is set to the end of the month of the
         * <code>minDate</code>.When called with a value of <code>null</code> or <code>undefined</code>, the
         * default value of the property will be restored.
         * @since 1.38.0
         * @param oMinDate New value for property <code>minDate</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setMinDate(oMinDate: any): sap.ui.unified.CalendarMonthInterval;

        /**
         * Sets a new value for property <code>months</code>.Number of months displayed<b>Note:</b> On phones,
         * the maximum number of months displayed in the row is always 6.When called with a value of
         * <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.Default value is <code>12</code>.
         * @param iMonths New value for property <code>months</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setMonths(iMonths: number): sap.ui.unified.CalendarMonthInterval;

        /**
         * Sets a new value for property <code>pickerPopup</code>.If set, the yearPicker opens on a popupWhen
         * called with a value of <code>null</code> or <code>undefined</code>, the default value of the
         * property will be restored.Default value is <code>false</code>.
         * @since 1.34.0
         * @param bPickerPopup New value for property <code>pickerPopup</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setPickerPopup(bPickerPopup: boolean): sap.ui.unified.CalendarMonthInterval;

        /**
         * Sets a new value for property <code>singleSelection</code>.If set, only a single date or interval,
         * if <code>intervalSelection</code> is enabled, can be selected<b>Note:</b> Selection of multiple
         * intervals is not supported in the current version.When called with a value of <code>null</code> or
         * <code>undefined</code>, the default value of the property will be restored.Default value is
         * <code>true</code>.
         * @param bSingleSelection New value for property <code>singleSelection</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setSingleSelection(bSingleSelection: boolean): sap.ui.unified.CalendarMonthInterval;

        /**
         * Sets a new value for property <code>startDate</code>.Start date of the Interval as JavaScript Date
         * object.The month of this Date will be the first month in the displayed row.When called with a value
         * of <code>null</code> or <code>undefined</code>, the default value of the property will be restored.
         * @param oStartDate New value for property <code>startDate</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setStartDate(oStartDate: any): sap.ui.unified.CalendarMonthInterval;

        /**
         * Sets a new value for property <code>width</code>.Width of the <code>CalendarMonthInterval</code>.
         * The width of the single months depends on this width.When called with a value of <code>null</code>
         * or <code>undefined</code>, the default value of the property will be restored.
         * @param sWidth New value for property <code>width</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setWidth(sWidth: any): sap.ui.unified.CalendarMonthInterval;
      }
      /**
       * Represents a parameter for the FileUploader which is rendered as a hidden inputfield.
       * @resource sap/ui/unified/FileUploaderParameter.js
      */
      export class FileUploaderParameter extends sap.ui.core.Element {


        /**
         * Constructor for a new FileUploaderParameter.Accepts an object literal <code>mSettings</code> that
         * defines initialproperty values, aggregated and associated objects as well as event handlers.See
         * {@link sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the
         * settings object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(sId: string, mSettings?: any);


        /**
         * Constructor for a new FileUploaderParameter.Accepts an object literal <code>mSettings</code> that
         * defines initialproperty values, aggregated and associated objects as well as event handlers.See
         * {@link sap.ui.base.ManagedObject#constructor} for a general description of the syntax of the
         * settings object.
         * @param sId id for the new control, generated automatically if no id is given
         * @param mSettings initial settings for the new control
        */
        constructor(mSettings?: any);

        /**
         * Returns a metadata object for class sap.ui.unified.FileUploaderParameter.
         * @returns Metadata object describing this class
        */
        getMetadata(): sap.ui.base.Metadata;

        /**
         * Gets current value of property <code>name</code>.The name of the hidden inputfield.
         * @since 1.12.2
         * @returns Value of property <code>name</code>
        */
        getName(): string;

        /**
         * Gets current value of property <code>value</code>.The value of the hidden inputfield.
         * @since 1.12.2
         * @returns Value of property <code>value</code>
        */
        getValue(): string;

        /**
         * Sets a new value for property <code>name</code>.The name of the hidden inputfield.When called with a
         * value of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.
         * @since 1.12.2
         * @param sName New value for property <code>name</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setName(sName: string): sap.ui.unified.FileUploaderParameter;

        /**
         * Sets a new value for property <code>value</code>.The value of the hidden inputfield.When called with
         * a value of <code>null</code> or <code>undefined</code>, the default value of the property will be
         * restored.
         * @since 1.12.2
         * @param sValue New value for property <code>value</code>
         * @returns Reference to <code>this</code> in order to allow method chaining
        */
        setValue(sValue: string): sap.ui.unified.FileUploaderParameter;
      }
      /**
       * Type of a calendar day used for visualization.
      */
      enum CalendarDayType {
        "None",
        "Type01",
        "Type02",
        "Type03",
        "Type04",
        "Type05",
        "Type06",
        "Type07",
        "Type08",
        "Type09",
        "Type10"
      }
      /**
       * Type of a interval in a <code>CalendarRow</code>.
      */
      enum CalendarIntervalType {
        "Day",
        "Hour",
        "Month"
      }
      /**
       * Predefined animations for the ContentSwitcher
      */
      enum ContentSwitcherAnimation {
        "Fade",
        "None",
        "Rotate",
        "SlideOver",
        "SlideRight",
        "ZoomIn",
        "ZoomOut"
      }
      /**
       * Visualisation of an <code>CalendarAppoinment</code> in a <code>CalendarRow</code>.
      */
      enum CalendarAppointmentVisualization {
        "Filled",
        "Standard"
      }
    }
  }
}