ni6uBjrF

1// Type definitions for PrimeFaces
2// Project: PrimeFaces https://github.com/primefaces
3// Definitions by: Andre Wachsmuth https://github.com/blutorange/
4
5/// <reference types="codemirror" />
6/// <reference types="ckeditor" />
7/// <reference types="jquery" />
8
9// Additional required type declarations for PrimeFaces that are not picked up from the source code
10
11/**
12 * An object that can be used to emulate classes and a class hierarchy in JavaScript. This works even for old
13 * browsers that do no support the native `class` syntax yet. Note however, that this should be mostly compatible
14 * with the new `class` syntax of JavaScript, so consider creating your own widgets as a class:
15 * 
16 * ```javascript
17 * class MyWidget extends PrimeFaces.widget.BaseWidget {
18 *   init(cfg){
19 *     // ...
20 *   }
21 * }
22 * ```
23 * 
24 * __Note to typescript users__: You will need to specify the type parameters explcitly. The best way to do so is by
25 * defining the interfaces for the classes separately:
26 * ```typescript
27 * interface BaseWidgetCfg {
28 *  prop1: string;
29 * }
30 * interface AccordionCfg extends BaseWidgetCfg {
31 *   prop2: boolean;
32 * }
33 * interface BaseWidget {
34 *   init(cfg: BaseWidgetCfg): void;
35 *   method1(x: number): boolean;
36 * }
37 * interface Accordion extends BaseWidget {
38 *   init(cfg: AccordionCfg): void;
39 *   method1(): boolean;
40 *   method2(): boolean;
41 * }
42 * ```
43 * 
44 * Now you can use it normally:
45 * ```typescript
46 * const BaseWidget = Class.extend<BaseWidget, [BaseWidgetCfg]>({
47 *   init(cfg: BaseWidgetCfg) {
48 *     // ...
49 *   },
50 *   method1(x: number): boolean {
51 *     return x > 0;
52 *   },
53 * });
54 * const Accordion = BaseWidget.extend<Accordion, [AccordionCfg]>({
55 *   init(cfg: AccordionCfg) {
56 *     this._super(cfg);
57 *   },
58 *   method1() {
59 *     return !this._super(42);
60 *   },
61 *   method2() {
62 *     return true;
63 *   }
64 * });
65 * const base: BaseWidget = new BaseWidget({prop1: ""});
66 * const accordion: Accordion = new Accordion({prop1: "", prop2: true});
67 * base.method1(2);
68 * accordion.method1();
69 * accordion.method2();
70 * ```
71 */
72declare const Class: PrimeFaces.Class;
73
74/**
75 * Finds and returns a widget
76 * 
77 * Note to typescript users: You should define a method that takes a widget variables and widget constructor, and
78 * check whether the widget is of the given type. If so, you can return the widget and cast it to the desired type:
79 * ```typescript
80 * function getWidget<T extends PrimeFaces.widget.BaseWidget>(widgetVar, ctor: Constructor<T>): T | undefined {
81 *   const widget = PrimeFaces.widget[widgetVar];
82 *   return widget !== undefined && widget instanceof ctor ? widget : undefined;
83 * }
84 * ```
85 * @return The widget with the given widget variable, or `undefined` if it cannot be found.
86 */
87declare function PF(widgetVar: string): PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> | undefined;
88
89declare namespace PrimeFaces {
90    /**
91     * Constructs a new type that is the union of all types of each property in T. 
92     * ```typescript
93     * type X = {a: ["bar", RegExp], b: ["foo", number]};
94     * type Y = ValueOf<X>;
95     * // type Y = ["bar", RegExp] | ["foo", number]
96     * ```
97     * @typeparam T A type with keys.
98     */
99    type ValueOf<T> = T[keyof T];
100
101    /**
102     * Constructs an object type a union of two-tuples. The first item in the pair
103     * is used as the key, the second item as the type of the property's value.
104     * ```typescript
105     * type Y = ["bar", RegExp] | ["foo", number];
106     * type Z = KeyValueTupleToObject<Y>;
107     * // type Z = { bar: RegExp; foo: number; }
108     * ```
109     * @typeparam T A union of pairs with the key and value for the oject's properties.
110     */
111    type KeyValueTupleToObject<T extends [keyof any, any]> = {
112        [K in T[0]]: Extract<T, [K, any]>[1]
113    };
114
115    /**
116     * Constructs a new type by renaming the properties in T according to the map M.
117     * ```typescript
118     * type Z = { bar: RegExp; foo: number; };
119     * type S = RenameKeys<Z, {bar: "b", foo: "f"}>;
120     * // type S = { b: RegExp; f: number; }
121     * ```
122     * @typeparam T Type with properties to rename
123     * @typeparam M Type that indicates how to rename the keys.
124     */
125    type RenameKeys<T, M extends Record<string, string>> =
126        KeyValueTupleToObject<ValueOf<{
127            [K in keyof T]: [K extends keyof M ? M[K] : K, T[K]]
128        }>>;
129
130    /**
131     * Constructs a new type by making all properties K in T optional.
132     * ```typescript
133     * type X = {foo: string, bar: string, baz: string};
134     * type Y = PartialBy<X, "foo" | "baz">;
135     * // type Y = {foo?: string, bar: string, baz?: string};
136     * ```
137     * @typeparam T Type for which some properties are made optional.
138     * @typeparam K Type of the keys that are made optional.
139     */
140    type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
141
142    /**
143     * Constructs a new type by binding the this context of T to another type S.
144     * ```typescript
145     * type X = (this: string, x: string) => boolean;
146     * type Y = BindThis<X, number>;
147     * // type Y = (this: number, x: string) => boolean
148     * ```
149     * @typeparam T Type to rebind.
150     * @typeparam S New this context for T.
151     * @return If T is a function type, that type with the this context bound to S. Otherwise, returns just T.
152     */
153    type BindThis<T, S> =
154        T extends (...args: any) => any ?
155            (this: S, ...args: Parameters<T>) => ReturnType<T> :
156            T;
157
158    /**
159     * Constructs a new type by binding the this context of T to another type S. Additionally, also adds a new property
160     * `_super` to the this context of T, that is also of type T.
161     * ```typescript
162     * type X = {foo: string, bar: number};
163     * type Y = (this: string, k: string) => boolean;
164     * type Z = BindThis<Y, X>;
165     * // type Z = (this: {foo: string, bar: number, _super: Y}, k: string) => boolean
166     * ``` 
167     * @typeparam T Type to rebind.
168     * @typeparam S New this context for T.
169     * @return If T is a function type, that type with the this context bound to S and with an additional property `_super`
170     * of type T added. Otherwise, returns just T.
171     */
172    type BindThisAndSuper<T, S> =
173        T extends (...args: any) => any ?
174            (this: S & {_super: T}, ...args: Parameters<T>) => ReturnType<T> :
175            T;
176
177    /**
178     * Given the type of the base class and the sub class, constructs a new type for the argument of `Class.extend(...)`,
179     * except that all properties are required.
180     * @typeparam TBase Type of the base class.
181     * @typeparam TSub Type of the subclass.
182     * @return A mapped type with properties P. If the property P is function type F, then the this context is bound to
183     * TSub. Additionally, if P is a property only of TBase and not of TSub, a special property `_super` of type F is added
184     * to the this context.
185     */
186    export type ClassExtendProps<TBase, TSub> = {
187        [P in keyof TSub]: P extends keyof TBase ? BindThisAndSuper<TBase[P], TSub> : BindThis<TSub[P], TSub> 
188    };
189
190    /**
191     * Constructs a new type for a constructor that takes Args and instantiates objects of type T.
192     * @typeparam Class Type of the instances created by the constructor.
193     * @typeparam Args Type of the arguments the constructor excepts. 
194     */
195    export type Constructor<Class, Args extends any[] = any[]> = new (...args: Args) => Class;
196
197    /**
198     * Constructs a new type that is the constructor type of T.
199     * @typeparam A type for which to retrieve the constructor type.
200     */
201    export type ConstructorType<T extends new(...args: any) => any> = new(...args: ConstructorParameters<T>) => InstanceType<T>;   
202
203    /**
204     * An object that can be used to emulate classes and a class hierarchy in JavaScript. This works even for old
205     * browsers that do no support the native `class` syntax yet. Note however, that this should be mostly compatible
206     * with the new `class` syntax of JavaScript, so consider creating your own widgets as a class:
207     * 
208     * ```javascript
209     * class MyWidget extends PrimeFaces.widget.BaseWidget {
210     *   init(cfg){
211     *     // ...
212     *   }
213     * }
214     * ```
215     * 
216     * Note for typescript users: You will need to specify the type parameters explcitly. The best way to do so is by
217     * defining the interfaces for the classes separately:
218     * ```typescript
219     * interface BaseWidgetCfg {
220     *  prop1: string;
221     * }
222     * interface AccordionCfg extends BaseWidgetCfg {
223     *   prop2: boolean;
224     * }
225     * interface BaseWidget {
226     *   init(cfg: BaseWidgetCfg): void;
227     *   method1(x: number): boolean;
228     * }
229     * interface Accordion extends BaseWidget {
230     *   init(cfg: AccordionCfg): void;
231     *   method1(): boolean;
232     *   method2(): boolean;
233     * }
234     * ```
235     * 
236     * Now you can use it normally:
237     * ```typescript
238     * const BaseWidget = Class.extend<BaseWidget, [BaseWidgetCfg]>({
239     *   init(cfg: BaseWidgetCfg) {
240     *     // ...
241     *   },
242     *   method1(x: number): boolean {
243     *     return x > 0;
244     *   },
245     * });
246     * const Accordion = BaseWidget.extend<Accordion, [AccordionCfg]>({
247     *   init(cfg: AccordionCfg) {
248     *     this._super(cfg);
249     *   },
250     *   method1() {
251     *     return !this._super(42);
252     *   },
253     *   method2() {
254     *     return true;
255     *   }
256     * });
257     * const base: BaseWidget = new BaseWidget({prop1: ""});
258     * const accordion: Accordion = new Accordion({prop1: "", prop2: true});
259     * base.method1(2);
260     * accordion.method1();
261     * accordion.method2();
262     * ```
263     */
264    export interface Class<TBase = {}> {
265        new (): Class<TBase>;
266        extend<
267            TSub extends {init(...args: TArgs): void} & Omit<TBase, "init">,
268            TArgs extends any[],
269        >(
270            prop: PartialBy<ClassExtendProps<TBase, TSub>, keyof Omit<TBase, "init">>
271        ): Class<TSub> & Constructor<TSub, TArgs> & {prototype: TSub};
272    }
273    
274    /**
275     * A shortcut for `PrimeFaces.ajax.Request.handle(cfg, ext)`, with shorter option names. Sends an AJAX request
276     * to the server and processes the response. You can use this method if you need more fine-grained control over
277     * which components you want to update or process, or if you need to change some other AJAX options.
278     */
279    export function ab(cfg: Partial<PrimeFaces.ajax.ShorthandConfiguration>, ext?: Partial<PrimeFaces.ajax.ConfigurationExtender>): void;
280    
281    /**
282     * A map with language specific translations. This is a map between the language keys and another map with the
283     * i18n keys mapped to the translation, for example:
284     * ```javascript
285     * {
286     *   "de": {
287     *     "currentText": "Aktuelles Datum",
288     *     "day": "Tag",
289     *     "dayNamesShort": ["So", "Mo", "Di", "Mi", "Do", "Fr", "Sa"],
290     *   },
291     *   "en": {
292     *     "currentText": "Current Date",
293     *     "day": "Day",
294     *     "dayNamesShort": ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
295     *   }
296     * }
297     * ```
298     */
299    export const locales: Record<string, Record<string, any>>;
300}
301
302declare namespace PrimeFaces.ajax {
303
304    /**
305     * Callback for an AJAX request that is always called after the request completes, irrespective of whether it
306     * succeeded or failed.
307     * @param xhr The XHR request that failed.
308     * @param status The type of error or success.
309     * @param pfArgs Internal arguments used by PrimeFaces.
310     * @param data The data that was returned by the request.
311     */
312    export type CallbackOncomplete = (this: Request, xhr: JQuery.jqXHR, status: JQuery.Ajax.TextStatus, pfArgs: Record<string, any>, data: any) => void;
313
314    /**
315     * Callback for an AJAX request that is called in case any error occured during the request, such as a a network
316     * error. Note that this is not called for errors in the application logic, such as when bean validation fails.
317     * @param xhr The XHR request that failed.
318     * @param status The type of error that occured.
319     * @param errorThrown The error with details on why the request failed.
320     */
321    export type CallbackOnerror = (this: Request, xhr: JQuery.jqXHR, status: JQuery.Ajax.ErrorTextStatus, errorThrown: string) => void;
322
323    /**
324     * Callback for an AJAX request that is called before the request is sent. Return `false` to cancel the request.
325     * @param cfg The current AJAX configuration.
326     * @return {boolean | undefined} `false` to abort and not send the request, `true` or `undefined` otherwise.
327     */
328    export type CallbackOnstart = (this: Request, cfg: Configuration) => boolean;
329
330    /**
331     * Callback for an AJAX request that is called when the request succeeds.
332     * @param data The data that was returned by the request.
333     * @param status The type of success, usually `success`.
334     * @param xhr The XHR request that succeeded.
335     * @return `true` if this handler already handle and/or parsed the response, `false` or `undefined` otherwise.
336     */
337    export type CallbackOnsuccess = (this: Request, data: any, status: JQuery.Ajax.SuccessTextStatus, xhr: JQuery.jqXHR) => boolean | undefined;
338
339    /**
340     * Describes a server callback parameter for an AJAX call. For example, when you call a
341     * `<p:remoteCommand name="myCommand" />` from the client, you may pass additional parameters to the backing
342     * bean like this:
343     * 
344     * ```javascript
345     * myCommand([
346     *   {
347     *     name: "MyParam",
348     *     value: "MyValue",
349     *   }
350     * ]);
351     * ```
352     * 
353     * In the backing bean, you can access this parameter like this:
354     * 
355     * ```java
356     * final String myParam = FacesContext.getCurrentInstance().getExternalContext().getRequestParameterMap().get("myParam");
357     * ```
358     * 
359     * @template T Type of the value of the callback parameter. Please note that it will be converted to string
360     * before it is passed to the server.
361     */
362    export interface ServerCallbackParameter<T = any> {
363        /** The name of the parameter to pass to the server. */
364        name: string;
365        /** The value of the parameter to pass to the server. */
366        value: T;
367    }
368
369    /**
370     * The options that can be passed to AJAX calls made by PrimeFaces. Note that you do not have to provide a value
371     * for all these property. Most methods methods such as `PrimeFaces.ab` have got sensible defaults in case you
372     * do not. 
373     */
374    export interface Configuration {
375        /**
376         * If `true`, the the request is sent immediately. When set to `false`, the AJAX request is added to a
377         * global queue to ensure that only one request is active at a time, and that each response is processed
378         * in order. Defaults to `false`.
379         */
380        async: boolean;
381        /**
382         * Delay in milliseconds. If less than this delay elapses between AJAX requests, only the most recent one is
383         * sent and all other requests are discarded. If this option is not specified, no delay is used.
384         */
385        delay: number;
386        /** 
387         * A PrimeFaces client-side search expression (such as `@widgetVar` or `@(.my-class)` for locating the form
388         * to with the input elements that are serialized. If not given, defaults to the enclosing form.
389         */
390        formId: string;
391        /**
392         * The AJAX behavior event that triggered the AJAX request.
393         */
394        event: string;
395        ext: ConfigurationExtender;
396        /**
397         * Additonal search expression that is added to the `process` option.
398         */
399        fragmentId: string;
400        /**
401         * Whether this AJAX request is global, ie whether it should trigger the global `<p:ajaxStatus />`. Defaults
402         * to `true`.
403         */
404        global: boolean;
405        /**
406         * `true` if components with `<p:autoUpdate/`> should be ignored and updated only if specified explicitly
407         * in the `update` option; or `false` otherwise. Defaults to `false`.
408         */
409        ignoreAutoUpdate: boolean;
410        /**
411         * Callback that is always called after the request completes, irrespective of whether it succeeded or
412         * failed.
413         */
414        oncomplete: CallbackOncomplete;
415        /**
416         * Callback that is called in case any error occured during the request, such as a a network error. Note
417         * that this is not called for errors in the application logic, such as when bean validation fails.
418         */
419        onerror: CallbackOnerror;
420        /**
421         * Callback that is called before the request is sent. Return `false` to cancel the request.
422         */
423        onstart: CallbackOnstart;
424        /**
425         * Callback that is called when the request succeeds.
426         */
427        onsuccess: CallbackOnsuccess;
428        /**
429         * Additional parameters that are passed to the server. These can be accessed as follows:
430         * 
431         * ```java
432         * final String myParam = FacesContext.getCurrentInstance().getExternalContext().getRequestParameterMap().get("myParam");
433         * ```
434         */
435        params: ServerCallbackParameter[];
436        /**
437         * `true` to perform a partial submit and not send the entire form data, but only the processed components;
438         * or `false` to send the entire form data. Defaults to `false`.
439         */
440        partialSubmit: boolean;
441        /**
442         * A CSS selector for finding the input elements of partially processed components. Defaults to `:input`.
443         */
444        partialSubmitFilter: string;
445        /**
446         * A (client-side) PrimeFaces search expression for the components to process in the AJAX request.
447         */
448        process: string;
449        /**
450         * `true` if the AJAX request is a reset request that resets the value of all form elements to their
451         * initial values, or `false` otherwise. Defaults to `false`.
452         */
453        resetValues: boolean;
454        /**
455         * `true` if child components should be skipped for the AJAX request, `false` otherwise. Used only by a few
456         * specific components.
457         */
458        skipChildren: boolean;
459        /**
460         * The source that triggered the AJAX request.
461         */
462        source: string | JQuery | HTMLElement;
463        /**
464         * Set a timeout (in milliseconds) for the request. A value of 0 means there will be no timeout.
465         */
466        timeout: number;
467        /**
468         * A (client-side) PrimeFaces search expression for the components to update in the AJAX request.
469         */
470        update: string;
471    }
472
473    /**
474     * Additional options that can be passed when sending an AJAX request to override the current options.
475     */
476    export type ConfigurationExtender = Pick<Configuration, "update" | "process" | "onstart" | "params" | "onerror" | "onsuccess" | "oncomplete"> & {
477        /**
478         * If given, this function is called once for each component. It is passed that serialized values for the
479         * component and should return the filtered values that are to be sent to the server. If not given, no
480         * values are filtered, and all values are send to the server.
481         * @param componentPostParams The serialized values of a component.
482         * @return The filtered values that are to be sent to the server.
483         */
484        partialSubmitParameterFilter(this: Request, componentPostParams: ServerCallbackParameter[]): ServerCallbackParameter[];
485    };
486
487    /**
488     * Options passed to AJAX calls made by PrimeFaces. This is the same as `Configuration`, but with shorter
489     * option names and is used mainly by the method `PrimeFaces.ab`. See `Configuration` for a detailed description
490     * of these options.
491     * @see PrimeFaces.ajax.Configuration
492     */
493    export type ShorthandConfiguration = RenameKeys<Configuration, {
494        source: "s",
495        formId: "f",
496        process: "p",
497        update: "u",
498        event: "e",
499        async: "a",
500        global: "g",
501        delay: "d",
502        timeout: "t",
503        skipChildren: "sc",
504        ignoreAutoUpdate: "iau",
505        partialSubmit: "ps",
506        partialSubmitFilter: "psf",
507        resetValues: "rv",
508        fragmentId: "fi",
509        params: "pa",
510        onstart: "onst",
511        onerror: "oner",
512        onsuccess: "onsu",
513        oncomplete: "onco",
514    }>;
515}
516
517declare namespace PrimeFaces.ajax.Utils {
518    // @TODO
519}
520
521declare namespace PrimeFaces.ajax.Request {
522    // @TODO
523}
524
525declare namespace PrimeFaces.ajax.Response {
526    // @TODO
527}
528
529declare namespace PrimeFaces.ajax.ResponseProcessor {
530    // @TODO
531}
532
533declare namespace PrimeFaces.ajax.Queue {
534    // @TODO
535}
536declare namespace PrimeFaces.widget {
537    /**
538     * PrimeFaces AccordionPanel widget.
539     * 
540     * The AccordionPanel is a container component that displays content in stacked format.
541     *
542     * @author Çağatay Çivici
543     */
544    export class AccordionPanel extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
545        /**
546         * The DOM elements for the header of each tab.
547         */
548        headers: JQuery;
549        /**
550         * The DOM elements for the content of each tab pabel.
551         */
552        panels: JQuery;
553        /**
554         * The configuration of this accordion widget instance.
555         */
556        cfg: PrimeFaces.widget.AccordionPanelCfg;
557        /**
558         * Initializes this accordion widget.
559         *
560         * @param cfg Configuration as created in the renderer.
561         */
562        init(cfg: PrimeFaces.widget.AccordionPanelCfg): void;
563        /**
564         * The content of a tab panel may be loaded dynamically on demand via AJAX. This method checks
565         * whether the content of a tab panel is currently loaded.
566         *
567         * @param panel A tab panel to check.
568         * @return `true` if the content of the tab panel is loaded, `false` otherwise.
569         */
570        isLoaded(panel: JQuery): boolean;
571        /**
572         * The content of a tab panel may be loaded dynamically on demand via AJAX. This method
573         * loads the content of the given tab. Make sure to check first that this widget has got
574         * dynamic tab panel (`cfg.dynamic`) and that the given tab panel is not loaded already
575         * (`#isLoaded`).
576         *
577         * @param panel A tab panel to load.
578         */
579        loadDynamicTab(panel: JQuery): void;
580        /**
581         * Activates (opens) the tab with given index. This may fail by returning `false`, such
582         * as when a callback is registered that prevent the tab from being opened.
583         *
584         * @param index 0-based index of the tab to open. Must not be out of range.
585         * @return `true` when the given panel is now active, `false` otherwise.
586         */
587        select(index: number): boolean;
588        /**
589         * Deactivates (closes) the tab with given index.
590         *
591         * @param index 0-based index of the tab to close. Must not be out of range.
592         */
593        unselect(index: number): void;
594    }
595}
596declare namespace PrimeFaces.widget {
597    export interface AccordionPanelCfg extends PrimeFaces.widget.BaseWidgetCfg {
598        /**
599         * List of tabs that are currenty active (open). Eaach item is a 0-based index of a tab.
600         */
601        active: number[];
602        /**
603         * `true` if activating a dynamic tab should not load the contents from server again and use the cached contents; or `false` if the caching is disabled.
604         */
605        cache: boolean;
606        /**
607         * The icon class name for the collapsed icon.
608         */
609        collapsedIcon: string;
610        /**
611         * `true` if a tab controller was specified for this widget; or `false` otherwise. A tab controller is a server side listener that decides whether a tab change or tab close should be allowed.
612         */
613        controlled: boolean;
614        /**
615         * `true` if the contents of each panel are loaded on-demand via AJAX; `false` otherwise.
616         */
617        dynamic: boolean;
618        /**
619         * The icon class name for the expanded icon.
620         */
621        expandedIcon: string;
622        /**
623         * `true` if multiple tabs may be open at the same time; or `false` if opening one tab closes all other tabs.
624         */
625        multiple: boolean;
626        /**
627         * `true` if the current text direction `rtl` (right-to-left); or `false` otherwise.
628         */
629        rtl: boolean;
630    }
631}
632declare namespace PrimeFaces.widget {
633    /**
634     * PrimeFaces AjaxStatus Widget
635     */
636    export class AjaxStatus extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
637        bind(): void;
638        bindToStandard(): void;
639        /**
640         * @param cfg
641         */
642        init(cfg?: any): void;
643        /**
644         * @param event
645         * @return
646         */
647        toFacetId(event?: any): any;
648        /**
649         * @param event
650         * @param args
651         */
652        trigger(event?: any, args?: any): void;
653    }
654}
655declare namespace PrimeFaces.widget {
656    /**
657     * PrimeFaces AutoComplete Widget
658     */
659    export class AutoComplete extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
660        activate(): void;
661        alignPanel(): void;
662        appendPanel(): void;
663        bindDropdownEvents(): void;
664        bindDynamicEvents(): void;
665        bindKeyEvents(): void;
666        bindStaticEvents(): void;
667        clearCache(): void;
668        close(): void;
669        deactivate(): void;
670        deleteTimeout(): void;
671        disable(): void;
672        disableDropdown(): void;
673        /**
674         * @param text
675         */
676        displayAriaStatus(text?: any): void;
677        enable(): void;
678        enableDropdown(): void;
679        fireClearEvent(): void;
680        /**
681         * @param group
682         * @param container
683         * @param tooltip
684         * @return
685         */
686        getGroupItem(group?: any, container?: any, tooltip?: any): any;
687        groupItems(): void;
688        hide(): void;
689        /**
690         * @param cfg
691         */
692        init(cfg?: any): void;
693        initCache(): void;
694        /**
695         * @param event
696         * @param itemValue
697         */
698        invokeItemSelectBehavior(event?: any, itemValue?: any): void;
699        /**
700         * @param event
701         * @param itemValue
702         */
703        invokeItemUnselectBehavior(event?: any, itemValue?: any): void;
704        invokeMoreTextBehavior(): void;
705        /**
706         * @param value
707         * @return
708         */
709        isValid(value?: any): any;
710        /**
711         * @param e
712         */
713        processKeyEvent(e?: any): void;
714        /**
715         * @param cfg
716         */
717        refresh(cfg?: any): void;
718        /**
719         * @param event
720         * @param item
721         */
722        removeItem(event?: any, item?: any): void;
723        /**
724         * @param query
725         */
726        search(query?: any): void;
727        searchWithDropdown(): void;
728        setupForceSelection(): void;
729        /**
730         * Binds events for multiple selection mode
731         */
732        setupMultipleMode(): void;
733        show(): void;
734        /**
735         * @param item
736         */
737        showItemtip(item?: any): void;
738        /**
739         * @param query
740         */
741        showSuggestions(query?: any): void;
742    }
743}
744declare namespace PrimeFaces.widget {
745    /**
746     * PrimeFaces BlockUI Widget
747     */
748    export class BlockUI extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
749        bindTriggers(): void;
750        /**
751         * @return
752         */
753        hasContent(): any;
754        hide(): void;
755        /**
756         * @param cfg
757         */
758        init(cfg?: any): void;
759        /**
760         * @param cfg
761         */
762        refresh(cfg?: any): void;
763        render(): void;
764        show(): void;
765    }
766}
767declare namespace PrimeFaces.widget {
768    /**
769     * PrimeFaces Calendar Widget
770     */
771    export class Calendar extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
772        alignPanel(): void;
773        bindCloseListener(): void;
774        bindDateSelectListener(): void;
775        bindViewChangeListener(): void;
776        configureLocale(): void;
777        configureTimePicker(): void;
778        disable(): void;
779        enable(): void;
780        fireCloseEvent(): void;
781        fireDateSelectEvent(): void;
782        /**
783         * @param year
784         * @param month
785         */
786        fireViewChangeEvent(year?: any, month?: any): void;
787        /**
788         * @return
789         */
790        getDate(): any;
791        /**
792         * @return
793         */
794        hasTimePicker(): any;
795        /**
796         * @param cfg
797         */
798        init(cfg?: any): void;
799        /**
800         * @param cfg
801         */
802        refresh(cfg?: any): void;
803        /**
804         * @param date
805         */
806        setDate(date?: any): void;
807    }
808}
809declare namespace PrimeFaces.widget {
810    /**
811     * PrimeFaces Captcha Widget
812     */
813    export class Captcha extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
814        destroy(): void;
815        /**
816         * @return
817         */
818        getInitCallbackName(): any;
819        /**
820         * @param cfg
821         */
822        init(cfg?: any): void;
823        render(): void;
824    }
825}
826declare namespace PrimeFaces.widget {
827    /**
828     * PrimeFaces Carousel Widget
829     */
830    export class Carousel extends PrimeFaces.widget.DeferredWidget<PrimeFaces.widget.DeferredWidgetCfg> {
831        bindEvents(): void;
832        calculateItemHeights(): void;
833        calculateItemWidths(): void;
834        clearState(): void;
835        collapse(): void;
836        expand(): void;
837        /**
838         * @param cfg
839         */
840        init(cfg?: any): void;
841        refreshDimensions(): void;
842        restoreState(): void;
843        saveState(): void;
844        /**
845         * @param p
846         */
847        setPage(p?: any): void;
848        slideDown(): void;
849        slideUp(): void;
850        startAutoplay(): void;
851        stopAutoplay(): void;
852        toggle(): void;
853        /**
854         * @param collapsed
855         * @param removeIcon
856         * @param addIcon
857         */
858        toggleState(collapsed?: any, removeIcon?: any, addIcon?: any): void;
859        updateNavigators(): void;
860    }
861}
862declare namespace PrimeFaces.widget {
863    export class BaseChart extends PrimeFaces.widget.DeferredWidget<PrimeFaces.widget.DeferredWidgetCfg> {
864        bindItemSelect(): void;
865        /**
866         * Return this chart as an <img src="data:url" />
867         *
868         * @return
869         */
870        exportAsImage(): any;
871        /**
872         * @param cfg
873         */
874        init(cfg?: any): void;
875    }
876}
877declare namespace PrimeFaces.widget {
878    /**
879     * PrimeFaces LineChart Widget
880     */
881    export class LineChart extends PrimeFaces.widget.BaseChart {
882    }
883}
884declare namespace PrimeFaces.widget {
885    /**
886     * PrimeFaces BarChart Widget
887     */
888    export class BarChart extends PrimeFaces.widget.BaseChart {
889    }
890}
891declare namespace PrimeFaces.widget {
892    /**
893     * PrimeFaces PieChart Widget
894     */
895    export class PieChart extends PrimeFaces.widget.BaseChart {
896    }
897}
898declare namespace PrimeFaces.widget {
899    /**
900     * PrimeFaces DonutChart Widget
901     */
902    export class DonutChart extends PrimeFaces.widget.BaseChart {
903    }
904}
905declare namespace PrimeFaces.widget {
906    /**
907     * PrimeFaces PolarAreaChart Widget
908     */
909    export class PolarAreaChart extends PrimeFaces.widget.BaseChart {
910    }
911}
912declare namespace PrimeFaces.widget {
913    /**
914     * PrimeFaces RadarChart Widget
915     */
916    export class RadarChart extends PrimeFaces.widget.BaseChart {
917    }
918}
919declare namespace PrimeFaces.widget {
920    /**
921     * PrimeFaces BubbleChart Widget
922     */
923    export class BubbleChart extends PrimeFaces.widget.BaseChart {
924    }
925}
926declare namespace PrimeFaces.widget {
927    /**
928     * PrimeFaces ScatterChart Widget
929     */
930    export class ScatterChart extends PrimeFaces.widget.BaseChart {
931    }
932}
933declare namespace PrimeFaces.widget {
934    /**
935     * PrimeFaces Chart Widget
936     */
937    export class Chart extends PrimeFaces.widget.DeferredWidget<PrimeFaces.widget.DeferredWidgetCfg> {
938        adjustLegendTable(): void;
939        bindItemSelect(): void;
940        configure(): void;
941        destroy(): void;
942        /**
943         * @return
944         */
945        exportAsImage(): any;
946        /**
947         * @param cfg
948         */
949        init(cfg?: any): void;
950        makeResponsive(): void;
951        /**
952         * @param cfg
953         */
954        refresh(cfg?: any): void;
955        resetZoom(): void;
956    }
957}
958declare namespace PrimeFaces.widget {
959    /**
960     * PrimeFaces Chips Widget
961     */
962    export class Chips extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
963        /**
964         * @param value
965         * @param refocus
966         */
967        addItem(value?: any, refocus?: any): void;
968        bindEvents(): void;
969        /**
970         * @param cfg
971         */
972        init(cfg?: any): void;
973        /**
974         * @param itemValue
975         */
976        invokeItemSelectBehavior(itemValue?: any): void;
977        /**
978         * @param itemValue
979         */
980        invokeItemUnselectBehavior(itemValue?: any): void;
981        /**
982         * @param item
983         */
984        removeItem(item?: any): void;
985    }
986}
987declare namespace PrimeFaces.widget {
988    /**
989     * PrimeFaces SimpleDateFormat widget, code ported from Tim Down's http://www.timdown.co.uk/code/simpledateformat.php
990     */
991    export class SimpleDateFormat {
992        /**
993         * @param date
994         * @return
995         */
996        format(date?: any): any;
997        /**
998         * @param date
999         * @return
1000         */
1001        getDayInYear(date?: any): any;
1002        /**
1003         * @param date1
1004         * @param date2
1005         * @return
1006         */
1007        getDifference(date1?: any, date2?: any): any;
1008        /**
1009         * @param days
1010         * @return
1011         */
1012        getMinimalDaysInFirstWeek(days?: any): any;
1013        /**
1014         * @param date
1015         * @return
1016         */
1017        getPreviousSunday(date?: any): any;
1018        /**
1019         * @param date1
1020         * @param date2
1021         * @return
1022         */
1023        getTimeSince(date1?: any, date2?: any): any;
1024        /**
1025         * @param date
1026         * @return
1027         */
1028        getUTCTime(date?: any): any;
1029        /**
1030         * @param date
1031         * @param minimalDaysInFirstWeek
1032         * @return
1033         */
1034        getWeekInMonth(date?: any, minimalDaysInFirstWeek?: any): any;
1035        /**
1036         * @param date
1037         * @param minimalDaysInFirstWeek
1038         * @return
1039         */
1040        getWeekInYear(date?: any, minimalDaysInFirstWeek?: any): any;
1041        /**
1042         * @param cfg
1043         */
1044        init(cfg?: any): void;
1045        /**
1046         * @param date1
1047         * @param date2
1048         * @return
1049         */
1050        isBefore(date1?: any, date2?: any): any;
1051        /**
1052         * @param year
1053         * @param month
1054         * @param day
1055         * @return
1056         */
1057        newDateAtMidnight(year?: any, month?: any, day?: any): any;
1058    }
1059}
1060declare namespace PrimeFaces.widget {
1061    /**
1062     * PrimeFaces Clock Widget
1063     */
1064    export class Clock extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
1065        draw(): void;
1066        draw_hands(): void;
1067        draw_hour_signs(): void;
1068        /**
1069         * @param size
1070         * @return
1071         */
1072        getDimensions(size?: any): any;
1073        /**
1074         * @param cfg
1075         */
1076        init(cfg?: any): void;
1077        /**
1078         * @return
1079         */
1080        isAnalogClock(): any;
1081        /**
1082         * @return
1083         */
1084        isClient(): any;
1085        /**
1086         * @param cfg
1087         */
1088        refresh(cfg?: any): void;
1089        start(): void;
1090        stop(): void;
1091        sync(): void;
1092        update(): void;
1093        updateOutput(): void;
1094    }
1095}
1096declare namespace PrimeFaces.widget {
1097    /**
1098     * PrimeFaces Color Picker Widget
1099     */
1100    export class ColorPicker extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
1101        bindCallbacks(): void;
1102        /**
1103         * When a popup colorpicker is updated with ajax, a new overlay is appended to body and old overlay
1104         * would be orphan. We need to remove the old overlay to prevent memory leaks.
1105         */
1106        clearOrphanOverlay(): void;
1107        /**
1108         * @param cfg
1109         */
1110        init(cfg?: any): void;
1111        setupDialogSupport(): void;
1112    }
1113}
1114declare namespace PrimeFaces.widget {
1115    /**
1116     * PrimeFaces ColumnToggler Widget
1117     */
1118    export class ColumnToggler extends PrimeFaces.widget.DeferredWidget<PrimeFaces.widget.DeferredWidgetCfg> {
1119        alignPanel(): void;
1120        bindEvents(): void;
1121        bindKeyEvents(): void;
1122        /**
1123         * @param column
1124         * @param isHidden
1125         */
1126        changeTogglerState(column?: any, isHidden?: any): void;
1127        /**
1128         * @param chkbox
1129         */
1130        check(chkbox?: any): void;
1131        /**
1132         * @param visible
1133         * @param index
1134         */
1135        fireToggleEvent(visible?: any, index?: any): void;
1136        hide(): void;
1137        /**
1138         * @param cfg
1139         */
1140        init(cfg?: any): void;
1141        /**
1142         * @param cfg
1143         */
1144        refresh(cfg?: any): void;
1145        render(): boolean;
1146        show(): void;
1147        /**
1148         * @param chkbox
1149         */
1150        toggle(chkbox?: any): void;
1151        /**
1152         * @param chkbox
1153         */
1154        uncheck(chkbox?: any): void;
1155        updateColspan(): void;
1156    }
1157}
1158declare namespace PrimeFaces.widget {
1159    /**
1160     * PrimeFaces ContentFlow Widget
1161     */
1162    export class ContentFlow extends PrimeFaces.widget.DeferredWidget<PrimeFaces.widget.DeferredWidgetCfg> {
1163        /**
1164         * @param cfg
1165         */
1166        init(cfg?: any): void;
1167    }
1168}
1169declare namespace PrimeFaces.widget {
1170    /**
1171     * BaseWidget for the PrimeFaces widgets framework. It provides some common functionality for other widgets.
1172     * All widgets should inherit from this class (or a sub class) in the following manner:
1173     * 
1174     * ```javascript
1175     * PrimeFaces.widget.MyWidget = PrimeFaces.widget.BaseWidget.extend({
1176     * init: function(cfg) {
1177     * this._super(cfg);
1178     * // custom initialization
1179     * }
1180     * });
1181     * ```
1182     */
1183    export class BaseWidget<T extends PrimeFaces.widget.BaseWidgetCfg> {
1184        /**
1185         * The client-side ID of this widget, with all parent naming containers, such as `myForm:myWidget`. This is also the ID of the container HTML element for this widget.
1186         */
1187        id: string;
1188        /**
1189         * The JQuery instance of the container element of this widget.
1190         */
1191        jq: JQuery;
1192        /**
1193         * The native DOM element instance of the container element of this widget.
1194         */
1195        jqEl: HTMLElement;
1196        /**
1197         * A CSS selector for the container element of this widget, This is usually an ID selector (that is properly escaped). You can select the container elements lke this: `jQuery(widget.jqId)`.
1198         */
1199        jqId: string;
1200        /**
1201         * The name of the widget variables of this widget. The widget variable can be used to access a widget instance by calling `PF('myWidgetVar')`.
1202         */
1203        widgetVar: string;
1204        /**
1205         * The configuration of this widget instance.
1206         */
1207        cfg: PrimeFaces.widget.BaseWidgetCfg;
1208        /**
1209         * Lets you register a listener that is called before the component is destroyed.
1210         * 
1211         * When an AJAX call is made and this component is updated, the DOM element is replaced with the newly rendered
1212         * content. When the element is removed from the DOM by the update, the DOM element is detached from the DOM and
1213         * all destroy listeners are called. This makes it possible to add listeners from outside the widget code.
1214         * 
1215         * If you call this method twice with the same listener, it will be registered twice and later also called
1216         * twice.
1217         * 
1218         * Note that for this to work, you must not override the `destroy` method; or if you do, call `super`.
1219         * 
1220         * Also, after this widget was detached is done, all destroy listeners will be deregistered.
1221         *
1222         * @param listener A destroy listener to be registered.
1223         */
1224        addDestroyListener(listener: (this: this, widget: this) => void): void;
1225        /**
1226         * When an AJAX call is made and this component is updated, the DOM element is replaced with the newly rendered
1227         * content. However, no new instance of the widget is created. Instead, after the DOM element was replaced, all
1228         * refresh listeners are called. This makes it possible to add listeners from outside the widget code.
1229         * 
1230         * If you call this method twice with the same listener, it will be registered twice and later also called
1231         * twice.
1232         * 
1233         * Note that for this to work, you must not override the `refresh` method; or if you do, call `super`.
1234         * 
1235         * Also, after the refresh is done, all refresh listeners will be deregistered. If you added the listeners from
1236         * within this widget, consider adding the refresh listeners not only in the `init` method, but also again in
1237         * the `refresh` method after calling `super`.
1238         *
1239         * @param listener A destroy listener to be registered.
1240         */
1241        addRefreshListener(listener: (this: this, widget: this) => void): void;
1242        /**
1243         * Each widget may have one or several behaviors attached to it. A behavior is a server-side callback, such as
1244         * those that may be added to a PrimeFaces component with the `<p:ajax event="..."/>` tag. This method calls
1245         * the behavior for the given event. In case no such behavior exists, does nothing and returns immediately.
1246         *
1247         * @param event The name of an event to call.
1248         * @param ext Addtional configuration that is passed to the
1249         * AJAX request for the server-side callback.
1250         */
1251        callBehavior(event: string, ext?: Partial<PrimeFaces.ajax.ConfigurationExtender>): void;
1252        /**
1253         * Will be called after an AJAX request if the widget container will be detached.
1254         * 
1255         * When an AJAX call is made and this component is updated, the DOM element is replaced with the newly rendered
1256         * content. When the element is removed from the DOM by the update, the DOM element is detached from the DOM and
1257         * this method gets called.
1258         * 
1259         * Please note that instead of overriding this method, you should consider adding a destroy listener instead
1260         * with the method `#addDestroyListener`. This has the advantage of letting you add multiple listeners, and
1261         * makes it possible to add additional listeners from code outside this widget.
1262         * 
1263         * By default, this method just calls all destroy listeners.
1264         */
1265        destroy(): void;
1266        /**
1267         * Each widget may have one or several behaviors attached to it. A behavior is a server-side callback, such as
1268         * those that may be added to a PrimeFaces component with the `<p:ajax event="..."/>` tag. This method returns
1269         * the callback function for the given event.
1270         *
1271         * @param name
1272         * @return  
1273         */
1274        getBehavior(name: any): ((this: this, ext?: Partial<PrimeFaces.ajax.ConfigurationExtender>) => void) | null;
1275        /**
1276         * Each widget has got a container element, this method returns that container. This container element is
1277         * usually also the element whose ID is the client-side ID of the JSF component.
1278         *
1279         * @return The JQuery instance representing the main HTML container element of this widget.
1280         */
1281        getJQ(): JQuery;
1282        /**
1283         * Each widget may have one or several behaviors attached to it. A behavior is a server-side callback, such
1284         * as those that may be added to a PrimeFaces component with the `<p:ajax event="..."/>` tag. This method checks
1285         * whether this widget has got a behavior for the given event.
1286         *
1287         * @param event The name of an event to check.
1288         * @return `true` if this widget has the given behavior, `false` otherwise.
1289         */
1290        hasBehavior(event: string): boolean;
1291        /**
1292         * A widget class should not have an explicit constructor. Instead, this initialize method is called after the widget
1293         * was created. You can use this method to perform any initialization that is required. For widgets that need to create
1294         * custom HTML on the client-side this is also the place where you should call your render method.
1295         * 
1296         * Please make sure to call the super method first before adding your own custom logic to the init method:
1297         * 
1298         * ```javascript
1299         * PrimeFaces.widget.MyWidget = PrimeFaces.widget.BaseWidget.extend({
1300         * init: function(cfg) {
1301         * this._super(cfg);
1302         * // custom initialization
1303         * }
1304         * });
1305         * ```
1306         *
1307         * @param cfg The widget configuration to be used for this widget instance. This widget configuration is usually created
1308         * on the server by the `javax.faces.render.Renderer` for this component.
1309         */
1310        init(cfg: T): void;
1311        /**
1312         * Checks if this widget is detached, ie whether the HTML element of this widget is currently contained within
1313         * the DOM (the HTML body element). A widget may become detached during an AJAX update, and it may remain
1314         * detached in case the update removed this component from the component tree.
1315         *
1316         * @return `true` if this widget is currently detached, or `false` otherwise.
1317         */
1318        isDetached(): boolean;
1319        /**
1320         * Used in ajax updates, reloads the widget configuration.
1321         * 
1322         * When an AJAX call is made and this component is updated, the DOM element is replaced with the newly rendered
1323         * content. However, no new instance of the widget is created. Instead, after the DOM element was replaced, this
1324         * method is called with the new widget configuration from the server. This makes it possible to persist
1325         * client-side state during an update, such as the currently selected tab.
1326         * 
1327         * Please note that instead of overriding this method, you should consider adding a refresh listener instead
1328         * with the method `#addRefreshListener`. This has the advantage of letting you add multiple listeners, and
1329         * makes it possible to add additional listeners from code outside this widget.
1330         * 
1331         * By default, this method calls all refresh listeners, then reinitializes the widget by calling the `init`
1332         * method.
1333         *
1334         * @param cfg The new widget configuration from the server.
1335         * @return The value returned by the `init` method.
1336         */
1337        refresh(cfg: T): unknown;
1338        /**
1339         * Removes the widget's script block from the DOM. Currently, the ID of this script block consists of the
1340         * client-side ID of this widget with the prefix `_s`, but this is subject to change.
1341         *
1342         * @param clientId The client-side ID of this widget.
1343         */
1344        removeScriptElement(clientId: string): void;
1345    }
1346}
1347declare namespace PrimeFaces.widget {
1348    export interface BaseWidgetCfg {
1349        /**
1350         * The client-side ID of this widget, with all parent naming containers, such as `myForm:myWidget`. This is also the ID of the container HTML element for this widget.
1351         */
1352        id: string;
1353        /**
1354         * The name of the widget variables of this widget. The widget variable can be used to access a widget instance by calling `PF("myWidgetVar")`.
1355         */
1356        widgetVar: string;
1357    }
1358}
1359declare namespace PrimeFaces.widget {
1360    export class DynamicOverlayWidget extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
1361        destroy(): void;
1362        disableModality(): void;
1363        enableModality(): void;
1364        /**
1365         * @return
1366         */
1367        getModalTabbables(): any;
1368        /**
1369         * @param cfg
1370         */
1371        init(cfg?: any): void;
1372        /**
1373         * @param cfg
1374         */
1375        refresh(cfg?: any): void;
1376    }
1377}
1378declare namespace PrimeFaces.widget {
1379    export type DeferredWidgetCfg = BaseWidgetCfg;
1380    /**
1381     * Base class for widgets that require to be visible to initialize properly. For example, a widget may need to
1382     * know the width and height if its container so that it can resize itself properly.
1383     * 
1384     * Do not call the `render` or `_render` method directly in the `init` method. Instead, call `renderDeferred`.
1385     * PrimeFaces will then check whether the widget is visible and call the `_render` method once it is. Make sure you
1386     * actually override the `_render` method, as the default implementation throws an error.
1387     */
1388    export abstract class DeferredWidget<T extends PrimeFaces.widget.DeferredWidgetCfg> extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
1389        /**
1390         * The configuration of this widget instance.
1391         */
1392        cfg: T;
1393        /**
1394         * Cleans up deferred render tasks. When you extend this class and override this method, make sure to call
1395         * `super`.
1396         */
1397        destroy(): void;
1398        /**
1399         * Called after the widget has become visible and after it was rendered. May be overriden, the default
1400         * implementation is a no-op.
1401         */
1402        postRender(): void;
1403        /**
1404         * This render method to check whether the widget container is visible. Do not override this method, or the
1405         * deferred widget functionality may not work properly anymore.
1406         *
1407         * @return `true` if the widget container is visible, `false` otherwise.
1408         */
1409        render(): boolean;
1410        /**
1411         * Call this method in the `init` method if you want deferred rendering support. This method checks whether the
1412         * container of this widget is visible and call `_render` only once it is.
1413         */
1414        renderDeferred(): void;
1415    }
1416}
1417declare namespace PrimeFaces.widget {
1418    /**
1419     * PrimeFaces Dashboard Widget
1420     */
1421    export class Dashboard extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
1422        /**
1423         * @param cfg
1424         */
1425        init(cfg?: any): void;
1426    }
1427}
1428declare namespace PrimeFaces.widget {
1429    /**
1430     * PrimeFaces DataGrid Widget
1431     */
1432    export class DataGrid extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
1433        /**
1434         * @return
1435         */
1436        getPaginator(): any;
1437        /**
1438         * @param newState
1439         */
1440        handlePagination(newState?: any): void;
1441        /**
1442         * @param cfg
1443         */
1444        init(cfg?: any): void;
1445        setupPaginator(): void;
1446    }
1447}
1448declare namespace PrimeFaces.widget {
1449    /**
1450     * PrimeFaces DataList Widget
1451     */
1452    export class DataList extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
1453        /**
1454         * @return
1455         */
1456        getPaginator(): any;
1457        /**
1458         * @param newState
1459         */
1460        handlePagination(newState?: any): void;
1461        /**
1462         * @param cfg
1463         */
1464        init(cfg?: any): void;
1465        setupPaginator(): void;
1466    }
1467}
1468declare namespace PrimeFaces.widget {
1469    /**
1470     * PrimeFaces DataScroller Widget
1471     */
1472    export class DataScroller extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
1473        bindManualLoader(): void;
1474        bindScrollListener(): void;
1475        /**
1476         * @param cfg
1477         */
1478        init(cfg?: any): void;
1479        load(): void;
1480        /**
1481         * @param page
1482         * @param callback
1483         */
1484        loadRowsWithVirtualScroll(page?: any, callback?: any): void;
1485        /**
1486         * @return
1487         */
1488        shouldLoad(): any;
1489        /**
1490         * @param data
1491         * @param clear
1492         */
1493        updateData(data?: any, clear?: any): void;
1494    }
1495}
1496declare namespace PrimeFaces.widget {
1497    /**
1498     * PrimeFaces DataTable Widget
1499     */
1500    export class DataTable extends PrimeFaces.widget.DeferredWidget<PrimeFaces.widget.DeferredWidgetCfg> {
1501        SORT_ORDER: any;
1502        addGhostRow(): void;
1503        addResizers(): void;
1504        addRow(): void;
1505        /**
1506         * Adds given rowKey to selection if it doesn't exist already
1507         *
1508         * @param rowKey
1509         */
1510        addSelection(rowKey?: any): void;
1511        /**
1512         * @param meta
1513         */
1514        addSortMeta(meta?: any): void;
1515        adjustScrollHeight(): void;
1516        adjustScrollWidth(): void;
1517        alignScrollBody(): void;
1518        /**
1519         * @param row
1520         */
1521        assignFocusedRow(row?: any): void;
1522        /**
1523         * @param filter
1524         */
1525        bindChangeFilter(filter?: any): void;
1526        bindCheckboxEvents(): void;
1527        /**
1528         * @param menuWidget
1529         * @param targetWidget
1530         * @param targetId
1531         * @param cfg
1532         */
1533        bindContextMenu(menuWidget?: any, targetWidget?: any, targetId?: any, cfg?: any): void;
1534        /**
1535         * Binds editor events non-obstrusively
1536         */
1537        bindEditEvents(): void;
1538        /**
1539         * @param filter
1540         */
1541        bindEnterKeyFilter(filter?: any): void;
1542        /**
1543         * Applies events related to row expansion in a non-obstrusive way
1544         */
1545        bindExpansionEvents(): void;
1546        /**
1547         * @param filter
1548         */
1549        bindFilterEvent(filter?: any): void;
1550        /**
1551         * Binds the change event listener and renders the paginator
1552         */
1553        bindPaginator(): void;
1554        bindRadioEvents(): void;
1555        bindRowClick(): void;
1556        bindRowEvents(): void;
1557        /**
1558         * @param selector
1559         */
1560        bindRowHover(selector?: any): void;
1561        /**
1562         * Applies events related to selection in a non-obstrusive way
1563         */
1564        bindSelectionEvents(): void;
1565        bindSelectionKeyEvents(): void;
1566        /**
1567         * Applies events related to sorting in a non-obstrusive way
1568         */
1569        bindSortEvents(): void;
1570        /**
1571         * @param filter
1572         */
1573        bindTextFilter(filter?: any): void;
1574        bindToggleRowGroupEvents(): void;
1575        /**
1576         * Cancels row editing
1577         *
1578         * @param rowEditor
1579         */
1580        cancelRowEdit(rowEditor?: any): void;
1581        /**
1582         * @param cell
1583         */
1584        cellEditInit(cell?: any): void;
1585        checkHeaderCheckbox(): void;
1586        clearCacheMap(): void;
1587        /**
1588         * Clears table filters
1589         */
1590        clearFilters(): void;
1591        clearScrollState(): void;
1592        /**
1593         * Clears the selection state
1594         */
1595        clearSelection(): void;
1596        cloneHead(): void;
1597        /**
1598         * Clones a table header and removes duplicate ids.
1599         *
1600         * @param thead
1601         * @param table
1602         * @return
1603         */
1604        cloneTableHeader(thead?: any, table?: any): any;
1605        collapseAllRows(): void;
1606        /**
1607         * @param row
1608         */
1609        collapseRow(row?: any): void;
1610        disableHeaderCheckbox(): void;
1611        /**
1612         * @param row
1613         * @param content
1614         */
1615        displayExpandedRow(row?: any, content?: any): void;
1616        /**
1617         * @param cell
1618         */
1619        doCellEditCancelRequest(cell?: any): void;
1620        /**
1621         * @param cell
1622         */
1623        doCellEditRequest(cell?: any): void;
1624        /**
1625         * Sends an ajax request to handle row save or cancel
1626         *
1627         * @param rowEditor
1628         * @param action
1629         */
1630        doRowEditRequest(rowEditor?: any, action?: any): void;
1631        enableHeaderCheckbox(): void;
1632        /**
1633         * Loads next page asynchronously to keep it at viewstate and Updates viewstate
1634         *
1635         * @param newState
1636         */
1637        fetchNextPage(newState?: any): void;
1638        /**
1639         * Ajax filter
1640         */
1641        filter(): void;
1642        /**
1643         * @param id
1644         * @return
1645         */
1646        findColWidthInResizableState(id?: any): any;
1647        /**
1648         * @param ui
1649         * @return
1650         */
1651        findGroupResizer(ui?: any): any;
1652        /**
1653         * @param r {Row Index || Row Element}
1654         * @return
1655         */
1656        findRow(r: any): any;
1657        /**
1658         * @param columnHeader
1659         */
1660        fireColumnResizeEvent(columnHeader?: any): void;
1661        /**
1662         * @param row
1663         */
1664        fireRowCollapseEvent(row?: any): void;
1665        /**
1666         * Sends a rowSelectEvent on server side to invoke a rowSelectListener if defined
1667         *
1668         * @param rowKey
1669         * @param behaviorEvent
1670         */
1671        fireRowSelectEvent(rowKey?: any, behaviorEvent?: any): void;
1672        /**
1673         * Sends a rowUnselectEvent on server side to invoke a rowUnselectListener if defined
1674         *
1675         * @param rowKey
1676         * @param behaviorEvent
1677         */
1678        fireRowUnselectEvent(rowKey?: any, behaviorEvent?: any): void;
1679        fixColumnWidths(): void;
1680        /**
1681         * @return
1682         */
1683        getExpandedRows(): any;
1684        /**
1685         * @return
1686         */
1687        getFocusableTbody(): any;
1688        /**
1689         * Returns the paginator instance if any defined
1690         *
1691         * @return
1692         */
1693        getPaginator(): any;
1694        /**
1695         * Finds all editors of a row
1696         *
1697         * @param row
1698         * @return
1699         */
1700        getRowEditors(row?: any): any;
1701        /**
1702         * @param row
1703         * @return
1704         */
1705        getRowMeta(row?: any): any;
1706        /**
1707         * @return
1708         */
1709        getScrollbarWidth(): any;
1710        /**
1711         * @return
1712         */
1713        getSelectedRowsCount(): any;
1714        /**
1715         * @param ariaLabel
1716         * @param sortOrderMessage
1717         * @return
1718         */
1719        getSortMessage(ariaLabel?: any, sortOrderMessage?: any): any;
1720        /**
1721         * @return
1722         */
1723        getTbody(): any;
1724        /**
1725         * @return
1726         */
1727        getTfoot(): any;
1728        /**
1729         * @return
1730         */
1731        getThead(): any;
1732        /**
1733         * @param colIndex
1734         * @param rows
1735         */
1736        groupRow(colIndex?: any, rows?: any): void;
1737        groupRows(): void;
1738        /**
1739         * @return
1740         */
1741        hasColGroup(): any;
1742        /**
1743         * @return
1744         */
1745        hasVerticalOverflow(): any;
1746        highlightFocusedRow(): void;
1747        /**
1748         * Highlights row as selected
1749         *
1750         * @param row
1751         */
1752        highlightRow(row?: any): void;
1753        /**
1754         * @param cfg
1755         */
1756        init(cfg?: any): void;
1757        initReflow(): void;
1758        /**
1759         * Displays row editors in invalid format
1760         *
1761         * @param index
1762         */
1763        invalidateRow(index?: any): void;
1764        /**
1765         * Returns true|false if checkbox selection is enabled|disabled
1766         *
1767         * @return
1768         */
1769        isCheckboxSelectionEnabled(): any;
1770        /**
1771         * Returns if there is any data displayed
1772         *
1773         * @return
1774         */
1775        isEmpty(): any;
1776        /**
1777         * @return
1778         */
1779        isMultipleSelection(): any;
1780        /**
1781         * Returns true|false if radio selection is enabled|disabled
1782         *
1783         * @return
1784         */
1785        isRadioSelectionEnabled(): any;
1786        /**
1787         * Finds if given rowKey is in selection
1788         *
1789         * @param rowKey
1790         * @return
1791         */
1792        isSelected(rowKey?: any): any;
1793        /**
1794         * Returns true|false if selection is enabled|disabled
1795         *
1796         * @return
1797         */
1798        isSelectionEnabled(): any;
1799        /**
1800         * @return
1801         */
1802        isSingleSelection(): any;
1803        /**
1804         * @param option
1805         * @return
1806         */
1807        joinSortMetaOption(option?: any): any;
1808        /**
1809         * @param row
1810         */
1811        lazyRowEditInit(row?: any): void;
1812        /**
1813         * @param newState
1814         */
1815        loadDataWithCache(newState?: any): void;
1816        /**
1817         * @param row
1818         */
1819        loadExpandedRowContent(row?: any): void;
1820        /**
1821         * Loads rows on-the-fly when scrolling live
1822         */
1823        loadLiveRows(): void;
1824        /**
1825         * @param page
1826         * @param callback
1827         */
1828        loadRowsWithVirtualScroll(page?: any, callback?: any): void;
1829        makeRowsDraggable(): void;
1830        /**
1831         * @param event
1832         * @param rowElement
1833         * @param silent
1834         */
1835        onRowClick(event?: any, rowElement?: any, silent?: any): void;
1836        /**
1837         * @param event
1838         * @param row
1839         */
1840        onRowDblclick(event?: any, row?: any): void;
1841        /**
1842         * @param event
1843         * @param rowElement
1844         * @param cmSelMode
1845         */
1846        onRowRightClick(event?: any, rowElement?: any, cmSelMode?: any): void;
1847        /**
1848         * Ajax pagination
1849         *
1850         * @param newState
1851         */
1852        paginate(newState?: any): void;
1853        postUpdateData(): void;
1854        reclone(): void;
1855        /**
1856         * @param cfg
1857         */
1858        refresh(cfg?: any): void;
1859        /**
1860         * Remove given rowIndex from selection
1861         *
1862         * @param rowIndex
1863         */
1864        removeSelection(rowIndex?: any): void;
1865        resetVirtualScrollBody(): void;
1866        /**
1867         * @param event
1868         * @param ui
1869         */
1870        resize(event?: any, ui?: any): void;
1871        restoreScrollState(): void;
1872        /**
1873         * @param cell
1874         */
1875        saveCell(cell?: any): void;
1876        saveColumnOrder(): void;
1877        /**
1878         * Saves the edited row
1879         *
1880         * @param rowEditor
1881         */
1882        saveRowEdit(rowEditor?: any): void;
1883        saveScrollState(): void;
1884        selectAllRows(): void;
1885        selectAllRowsOnPage(): void;
1886        /**
1887         * @param checkbox
1888         */
1889        selectCheckbox(checkbox?: any): void;
1890        /**
1891         * @param radio
1892         */
1893        selectRadio(radio?: any): void;
1894        /**
1895         * @param r
1896         * @param silent
1897         */
1898        selectRow(r?: any, silent?: any): void;
1899        /**
1900         * Selects the corresponding row of a checkbox based column selection
1901         *
1902         * @param checkbox
1903         * @param silent
1904         */
1905        selectRowWithCheckbox(checkbox?: any, silent?: any): void;
1906        /**
1907         * Selects the corresping row of a radio based column selection
1908         *
1909         * @param radio
1910         */
1911        selectRowWithRadio(radio?: any): void;
1912        /**
1913         * @param row
1914         */
1915        selectRowsInRange(row?: any): void;
1916        /**
1917         * @param columns
1918         */
1919        setColumnsWidth(columns?: any): void;
1920        /**
1921         * @param element
1922         * @param width
1923         */
1924        setOuterWidth(element?: any, width?: any): void;
1925        /**
1926         * @param width
1927         */
1928        setScrollWidth(width?: any): void;
1929        setupDraggableColumns(): void;
1930        /**
1931         * Binds filter events to standard filters
1932         */
1933        setupFiltering(): void;
1934        setupResizableColumns(): void;
1935        setupRowHover(): void;
1936        setupScrolling(): void;
1937        setupSelection(): void;
1938        setupStickyHeader(): void;
1939        /**
1940         * @return
1941         */
1942        shouldLoadLiveScroll(): any;
1943        /**
1944         * @param event
1945         * @param column
1946         * @return
1947         */
1948        shouldSort(event?: any, column?: any): any;
1949        /**
1950         * @param c
1951         */
1952        showCellEditor(c?: any): void;
1953        /**
1954         * @param cell
1955         */
1956        showCurrentCell(cell?: any): void;
1957        /**
1958         * @param row
1959         */
1960        showRowEditors(row?: any): void;
1961        /**
1962         * Ajax sort
1963         *
1964         * @param columnHeader
1965         * @param order
1966         * @param multi
1967         */
1968        sort(columnHeader?: any, order?: any, multi?: any): void;
1969        /**
1970         * @param row
1971         */
1972        switchToRowEdit(row?: any): void;
1973        syncRowParity(): void;
1974        /**
1975         * @param cell
1976         * @param forward
1977         */
1978        tabCell(cell?: any, forward?: any): void;
1979        /**
1980         * Toggles all rows with checkbox
1981         */
1982        toggleCheckAll(): void;
1983        /**
1984         * Expands a row to display detail content
1985         *
1986         * @param toggler
1987         */
1988        toggleExpansion(toggler?: any): void;
1989        /**
1990         * @param row
1991         */
1992        toggleRow(row?: any): void;
1993        /**
1994         * Unbinds events needed if refreshing to prevent multiple sort and pagination events.
1995         */
1996        unbindEvents(): void;
1997        uncheckHeaderCheckbox(): void;
1998        unhighlightFocusedRow(): void;
1999        /**
2000         * Clears selected visuals
2001         *
2002         * @param row
2003         */
2004        unhighlightRow(row?: any): void;
2005        unselectAllRows(): void;
2006        unselectAllRowsOnPage(): void;
2007        /**
2008         * @param checkbox
2009         */
2010        unselectCheckbox(checkbox?: any): void;
2011        /**
2012         * @param radio
2013         */
2014        unselectRadio(radio?: any): void;
2015        /**
2016         * @param r
2017         * @param silent
2018         */
2019        unselectRow(r?: any, silent?: any): void;
2020        /**
2021         * Unselects the corresponding row of a checkbox based column selection
2022         *
2023         * @param checkbox
2024         * @param silent
2025         */
2026        unselectRowWithCheckbox(checkbox?: any, silent?: any): void;
2027        updateColumnsView(): void;
2028        /**
2029         * @param data
2030         * @param clear
2031         */
2032        updateData(data?: any, clear?: any): void;
2033        updateEmptyColspan(): void;
2034        updateHeaderCheckbox(): void;
2035        /**
2036         * @param newState
2037         */
2038        updatePageState(newState?: any): void;
2039        /**
2040         * @param columnHeader
2041         * @param sortOrder
2042         */
2043        updateReflowDD(columnHeader?: any, sortOrder?: any): void;
2044        /**
2045         * @param columnHeader
2046         * @param nextColumnHeader
2047         * @param table
2048         * @param newWidth
2049         * @param nextColumnWidth
2050         */
2051        updateResizableState(columnHeader?: any, nextColumnHeader?: any, table?: any, newWidth?: any, nextColumnWidth?: any): void;
2052        /**
2053         * Updates row with given content
2054         *
2055         * @param row
2056         * @param content
2057         */
2058        updateRow(row?: any, content?: any): void;
2059        /**
2060         * @param cell
2061         */
2062        viewMode(cell?: any): void;
2063        /**
2064         * Writes selected row ids to state holder
2065         */
2066        writeSelections(): void;
2067    }
2068}
2069declare namespace PrimeFaces.widget {
2070    /**
2071     * PrimeFaces DataTable with Frozen Columns Widget
2072     */
2073}
2074declare namespace PrimeFaces.widget {
2075    /**
2076     * PrimeFaces DataView Widget
2077     */
2078    export class DataView extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
2079        bindEvents(): void;
2080        /**
2081         * @return
2082         */
2083        getPaginator(): any;
2084        /**
2085         * @param newState
2086         */
2087        handlePagination(newState?: any): void;
2088        /**
2089         * @param cfg
2090         */
2091        init(cfg?: any): void;
2092        /**
2093         * @param layout
2094         */
2095        loadLayoutContent(layout?: any): void;
2096        /**
2097         * @param button
2098         */
2099        select(button?: any): void;
2100        setupPaginator(): void;
2101    }
2102}
2103declare namespace PrimeFaces.widget {
2104    /**
2105     * PrimeFaces DatePicker Widget
2106     */
2107    export class DatePicker extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
2108        bindCloseListener(): void;
2109        bindDateSelectListener(): void;
2110        bindViewChangeListener(): void;
2111        configureLocale(): void;
2112        fireCloseEvent(): void;
2113        fireDateSelectEvent(): void;
2114        /**
2115         * @param year
2116         * @param month
2117         */
2118        fireViewChangeEvent(year?: any, month?: any): void;
2119        /**
2120         * Gets the date value of the DatePicker
2121         *
2122         * @return
2123         */
2124        getDate(): any;
2125        /**
2126         * Gets the displayed visible calendar date.
2127         *
2128         * @return
2129         */
2130        getViewDate(): any;
2131        /**
2132         * @param cfg
2133         */
2134        init(cfg?: any): void;
2135        /**
2136         * Sets the date value the DatePicker.
2137         *
2138         * @param date
2139         */
2140        setDate(date?: any): void;
2141        /**
2142         * Sets the displayed visible calendar date.
2143         *
2144         * @param date
2145         */
2146        setViewDate(date?: any): void;
2147    }
2148}
2149declare namespace PrimeFaces.widget {
2150    /**
2151     * PrimeFaces Diagram Widget
2152     */
2153    export class Diagram extends PrimeFaces.widget.DeferredWidget<PrimeFaces.widget.DeferredWidgetCfg> {
2154        bindEvents(): void;
2155        /**
2156         * @param cfg
2157         */
2158        init(cfg?: any): void;
2159        initConnections(): void;
2160        initEndPoints(): void;
2161        /**
2162         * @param info
2163         */
2164        onConnect(info?: any): void;
2165        /**
2166         * @param info
2167         */
2168        onConnectionChange(info?: any): void;
2169        /**
2170         * @param info
2171         */
2172        onDisconnect(info?: any): void;
2173    }
2174}
2175declare namespace PrimeFaces.widget {
2176    /**
2177     * PrimeFaces Dialog Widget
2178     */
2179    export class Dialog extends PrimeFaces.widget.DynamicOverlayWidget {
2180        applyARIA(): void;
2181        applyFocus(): void;
2182        bindEvents(): void;
2183        bindResizeListener(): void;
2184        /**
2185         * @param zone
2186         */
2187        dock(zone?: any): void;
2188        fitViewport(): void;
2189        /**
2190         * @return
2191         */
2192        getModalTabbables(): any;
2193        hide(): void;
2194        /**
2195         * @param cfg
2196         */
2197        init(cfg?: any): void;
2198        initPosition(): void;
2199        initSize(): void;
2200        /**
2201         * @return
2202         */
2203        isVisible(): any;
2204        loadContents(): void;
2205        moveToTop(): void;
2206        /**
2207         * @param event
2208         * @param ui
2209         */
2210        onHide(event?: any, ui?: any): void;
2211        postShow(): void;
2212        /**
2213         * @param cfg
2214         */
2215        refresh(cfg?: any): void;
2216        removeMinimize(): void;
2217        /**
2218         * Reset the dialog position based on the configured "position".
2219         */
2220        resetPosition(): void;
2221        restoreState(): void;
2222        saveState(): void;
2223        setupDraggable(): void;
2224        setupResizable(): void;
2225        show(): void;
2226        toggleMaximize(): void;
2227        toggleMinimize(): void;
2228    }
2229}
2230declare namespace PrimeFaces.widget {
2231    /**
2232     * PrimeFace Dock Widget
2233     */
2234    export class Dock extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
2235        /**
2236         * @param cfg
2237         */
2238        init(cfg?: any): void;
2239    }
2240}
2241declare namespace PrimeFaces.widget {
2242    /**
2243     * PrimeFaces Draggable Widget
2244     */
2245    export class Draggable extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
2246        /**
2247         * @param cfg
2248         */
2249        init(cfg?: any): void;
2250    }
2251}
2252declare namespace PrimeFaces.widget {
2253    /**
2254     * PrimeFaces Droppable Widget
2255     */
2256    export class Droppable extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
2257        bindDropListener(): void;
2258        /**
2259         * @param cfg
2260         */
2261        init(cfg?: any): void;
2262    }
2263}
2264declare namespace PrimeFaces.widget {
2265    /**
2266     * PrimeFaces Editor Widget
2267     */
2268}
2269declare namespace PrimeFaces.widget {
2270    /**
2271     * PrimeFaces Effect Widget
2272     */
2273    export class Effect extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
2274        /**
2275         * @param cfg
2276         */
2277        init(cfg?: any): void;
2278    }
2279}
2280declare namespace PrimeFaces.widget {
2281    /**
2282     * PrimeFaces Fieldset Widget
2283     */
2284    export class Fieldset extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
2285        /**
2286         * @param cfg
2287         */
2288        init(cfg?: any): void;
2289        /**
2290         * Toggles the content
2291         *
2292         * @param e
2293         */
2294        toggle(e?: any): void;
2295        /**
2296         * Updates the visual toggler state and saves state
2297         *
2298         * @param collapsed
2299         */
2300        updateToggleState(collapsed?: any): void;
2301    }
2302}
2303declare namespace PrimeFaces.widget {
2304    /**
2305     * PrimeFaces FileUpload Widget
2306     */
2307    export class FileUpload extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
2308        IMAGE_TYPES: any;
2309        /**
2310         * @param file
2311         * @param data
2312         */
2313        addFileToRow(file?: any, data?: any): void;
2314        bindEvents(): void;
2315        clear(): void;
2316        clearMessages(): void;
2317        /**
2318         * @return
2319         */
2320        createPostData(): any;
2321        /**
2322         * @param btn
2323         */
2324        disableButton(btn?: any): void;
2325        /**
2326         * @param btn
2327         */
2328        enableButton(btn?: any): void;
2329        /**
2330         * @param bytes
2331         * @return
2332         */
2333        formatSize(bytes?: any): any;
2334        /**
2335         * @param cfg
2336         */
2337        init(cfg?: any): void;
2338        /**
2339         * @param data
2340         */
2341        postSelectFile(data?: any): void;
2342        /**
2343         * @param file
2344         */
2345        removeFile(file?: any): void;
2346        /**
2347         * @param row
2348         */
2349        removeFileRow(row?: any): void;
2350        /**
2351         * @param files
2352         */
2353        removeFiles(files?: any): void;
2354        renderMessages(): void;
2355        /**
2356         * @param msg
2357         */
2358        showMessage(msg?: any): void;
2359        upload(): void;
2360        /**
2361         * @param file
2362         * @return
2363         */
2364        validate(file?: any): any;
2365    }
2366}
2367declare namespace PrimeFaces.widget {
2368    /**
2369     * PrimeFaces Simple FileUpload Widget
2370     */
2371    export class SimpleFileUpload extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
2372        bindEvents(): void;
2373        /**
2374         * @param cfg
2375         */
2376        init(cfg?: any): void;
2377        /**
2378         * @param input
2379         * @param file
2380         * @return
2381         */
2382        validate(input?: any, file?: any): any;
2383    }
2384}
2385declare namespace PrimeFaces.widget {
2386    /**
2387     * PrimeFaces Button Widget
2388     */
2389    export class Button extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
2390        disable(): void;
2391        enable(): void;
2392        /**
2393         * @param cfg
2394         */
2395        init(cfg?: any): void;
2396    }
2397}
2398declare namespace PrimeFaces.widget {
2399    /**
2400     * PrimeFaces CommandButton Widget
2401     */
2402    export class CommandButton extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
2403        disable(): void;
2404        enable(): void;
2405        /**
2406         * @param cfg
2407         */
2408        init(cfg?: any): void;
2409    }
2410}
2411declare namespace PrimeFaces.widget {
2412    /**
2413     * PrimeFaces DefaultCommand Widget
2414     */
2415    export class DefaultCommand extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
2416        /**
2417         * @param cfg
2418         */
2419        init(cfg?: any): void;
2420    }
2421}
2422declare namespace PrimeFaces.widget {
2423    /**
2424     * PrimeFaces InputMask Widget
2425     */
2426    export class InputMask extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
2427        /**
2428         * @return
2429         */
2430        getValue(): any;
2431        /**
2432         * @param cfg
2433         */
2434        init(cfg?: any): void;
2435        /**
2436         * @param value
2437         */
2438        setValue(value?: any): void;
2439    }
2440}
2441declare namespace PrimeFaces.widget {
2442    /**
2443     * PrimeFaces InputText Widget
2444     */
2445    export class InputText extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
2446        disable(): void;
2447        enable(): void;
2448        /**
2449         * @param cfg
2450         */
2451        init(cfg?: any): void;
2452        /**
2453         * @param text
2454         * @return
2455         */
2456        normalizeNewlines(text?: any): any;
2457        updateCounter(): void;
2458    }
2459}
2460declare namespace PrimeFaces.widget {
2461    /**
2462     * PrimeFaces InputTextarea Widget
2463     */
2464    export class InputTextarea extends PrimeFaces.widget.DeferredWidget<PrimeFaces.widget.DeferredWidgetCfg> {
2465        alignPanel(): void;
2466        applyMaxlength(): void;
2467        bindDynamicEvents(): void;
2468        clearTimeout(): void;
2469        /**
2470         * @return
2471         */
2472        extractQuery(): any;
2473        hide(): void;
2474        /**
2475         * @param cfg
2476         */
2477        init(cfg?: any): void;
2478        /**
2479         * @param event
2480         * @param itemValue
2481         */
2482        invokeItemSelectBehavior(event?: any, itemValue?: any): void;
2483        /**
2484         * @param text
2485         * @return
2486         */
2487        normalizeNewlines(text?: any): any;
2488        /**
2489         * @param cfg
2490         */
2491        refresh(cfg?: any): void;
2492        /**
2493         * @param query
2494         */
2495        search(query?: any): void;
2496        setupAutoComplete(): void;
2497        setupAutoResize(): void;
2498        setupDialogSupport(): void;
2499        show(): void;
2500        updateCounter(): void;
2501    }
2502}
2503declare namespace PrimeFaces.widget {
2504    /**
2505     * PrimeFaces LinkButton Widget
2506     */
2507    export class LinkButton extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
2508        /**
2509         * @param cfg
2510         */
2511        init(cfg?: any): void;
2512    }
2513}
2514declare namespace PrimeFaces.widget {
2515    /**
2516     * PrimeFaces MultiSelectListbox Widget
2517     */
2518    export class MultiSelectListbox extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
2519        bindEvents(): void;
2520        disable(): void;
2521        enable(): void;
2522        /**
2523         * @param cfg
2524         */
2525        init(cfg?: any): void;
2526        /**
2527         * @param value
2528         */
2529        preselect(value?: any): void;
2530        /**
2531         * @param item
2532         */
2533        showOptionGroup(item?: any): void;
2534        triggerChange(): void;
2535        unbindEvents(): void;
2536    }
2537}
2538declare namespace PrimeFaces.widget {
2539    /**
2540     * PrimeFaces Password
2541     */
2542    export class Password extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
2543        align(): void;
2544        hide(): void;
2545        /**
2546         * @param cfg
2547         */
2548        init(cfg?: any): void;
2549        /**
2550         * @param x
2551         * @param y
2552         * @return
2553         */
2554        normalize(x?: any, y?: any): any;
2555        setupFeedback(): void;
2556        show(): void;
2557        /**
2558         * @param password
2559         * @return
2560         */
2561        testStrength(password?: any): any;
2562    }
2563}
2564declare namespace PrimeFaces.widget {
2565    /**
2566     * PrimeFaces SelectBooleanButton Widget
2567     */
2568    export class SelectBooleanButton extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
2569        check(): void;
2570        /**
2571         * @param cfg
2572         */
2573        init(cfg?: any): void;
2574        toggle(): void;
2575        uncheck(): void;
2576    }
2577}
2578declare namespace PrimeFaces.widget {
2579    /**
2580     * PrimeFaces SelectBooleanCheckbox Widget
2581     */
2582    export class SelectBooleanCheckbox extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
2583        check(): void;
2584        /**
2585         * @param cfg
2586         */
2587        init(cfg?: any): void;
2588        /**
2589         * @return
2590         */
2591        isChecked(): any;
2592        toggle(): void;
2593        uncheck(): void;
2594    }
2595}
2596declare namespace PrimeFaces.widget {
2597    /**
2598     * PrimeFaces SelectCheckboxMenu Widget
2599     */
2600    export class SelectCheckboxMenu extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
2601        alignPanel(): void;
2602        /**
2603         * @param item
2604         */
2605        bindCheckboxHover(item?: any): void;
2606        /**
2607         * @param items
2608         */
2609        bindCheckboxKeyEvents(items?: any): void;
2610        bindEvents(): void;
2611        bindKeyEvents(): void;
2612        bindMultipleModeEvents(): void;
2613        bindPanelEvents(): void;
2614        bindPanelKeyEvents(): void;
2615        /**
2616         * @param checkbox
2617         * @param updateInput
2618         */
2619        check(checkbox?: any, updateInput?: any): void;
2620        checkAll(): void;
2621        /**
2622         * @param value
2623         * @param filter
2624         * @return
2625         */
2626        containsFilter(value?: any, filter?: any): any;
2627        /**
2628         * @param item
2629         */
2630        createMultipleItem(item?: any): void;
2631        /**
2632         * @param value
2633         * @param filter
2634         * @return
2635         */
2636        endsWithFilter(value?: any, filter?: any): any;
2637        /**
2638         * @param value
2639         */
2640        filter(value?: any): void;
2641        /**
2642         * @param checked
2643         */
2644        fireToggleSelectEvent(checked?: any): void;
2645        /**
2646         * @param animate
2647         */
2648        hide(animate?: any): void;
2649        /**
2650         * @param cfg
2651         */
2652        init(cfg?: any): void;
2653        postHide(): void;
2654        postShow(): void;
2655        /**
2656         * @param cfg
2657         */
2658        refresh(cfg?: any): void;
2659        /**
2660         * @param item
2661         */
2662        removeMultipleItem(item?: any): void;
2663        renderHeader(): void;
2664        renderItems(): void;
2665        renderPanel(): void;
2666        /**
2667         * @param value
2668         */
2669        selectValue(value?: any): void;
2670        setupFilterMatcher(): void;
2671        show(): void;
2672        /**
2673         * @param value
2674         * @param filter
2675         * @return
2676         */
2677        startsWithFilter(value?: any, filter?: any): any;
2678        /**
2679         * @param checkbox
2680         */
2681        toggleItem(checkbox?: any): void;
2682        /**
2683         * @param checkbox
2684         * @param updateInput
2685         */
2686        uncheck(checkbox?: any, updateInput?: any): void;
2687        uncheckAll(): void;
2688        updateLabel(): void;
2689        updateToggler(): void;
2690    }
2691}
2692declare namespace PrimeFaces.widget {
2693    /**
2694     * PrimeFaces SelectListbox Widget
2695     */
2696    export class SelectListbox extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
2697        bindEvents(): void;
2698        /**
2699         * @param value
2700         * @param filter
2701         * @return
2702         */
2703        containsFilter(value?: any, filter?: any): any;
2704        /**
2705         * @param value
2706         * @param filter
2707         * @return
2708         */
2709        endsWithFilter(value?: any, filter?: any): any;
2710        /**
2711         * @param value
2712         */
2713        filter(value?: any): void;
2714        /**
2715         * @param cfg
2716         */
2717        init(cfg?: any): void;
2718        /**
2719         * @param item
2720         */
2721        selectItem(item?: any): void;
2722        setupFilterMatcher(): void;
2723        /**
2724         * @param value
2725         * @param filter
2726         * @return
2727         */
2728        startsWithFilter(value?: any, filter?: any): any;
2729        unselectAll(): void;
2730        /**
2731         * @param item
2732         */
2733        unselectItem(item?: any): void;
2734    }
2735}
2736declare namespace PrimeFaces.widget {
2737    /**
2738     * PrimeFaces SelecyManyButton Widget
2739     */
2740    export class SelectManyButton extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
2741        bindEvents(): void;
2742        /**
2743         * @param cfg
2744         */
2745        init(cfg?: any): void;
2746        /**
2747         * @param button
2748         */
2749        select(button?: any): void;
2750        /**
2751         * @param button
2752         */
2753        unselect(button?: any): void;
2754    }
2755}
2756declare namespace PrimeFaces.widget {
2757    /**
2758     * PrimeFaces SelectManyCheckbox Widget
2759     */
2760    export class SelectManyCheckbox extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
2761        bindEvents(): void;
2762        /**
2763         * @param cfg
2764         */
2765        init(cfg?: any): void;
2766    }
2767}
2768declare namespace PrimeFaces.widget {
2769    /**
2770     * PrimeFaces SelectManyMenu Widget
2771     */
2772    export class SelectManyMenu extends PrimeFaces.widget.SelectListbox {
2773        bindEvents(): void;
2774        /**
2775         * @param cfg
2776         */
2777        init(cfg?: any): void;
2778        selectAll(): void;
2779        /**
2780         * @param chkbox
2781         */
2782        selectCheckbox(chkbox?: any): void;
2783        /**
2784         * @param item
2785         */
2786        selectItem(item?: any): void;
2787        unselectAll(): void;
2788        /**
2789         * @param chkbox
2790         */
2791        unselectCheckbox(chkbox?: any): void;
2792        /**
2793         * @param item
2794         */
2795        unselectItem(item?: any): void;
2796    }
2797}
2798declare namespace PrimeFaces.widget {
2799    /**
2800     * PrimeFaces SelectOneButton Widget
2801     */
2802    export class SelectOneButton extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
2803        bindEvents(): void;
2804        disable(): void;
2805        enable(): void;
2806        /**
2807         * @param cfg
2808         */
2809        init(cfg?: any): void;
2810        /**
2811         * @param button
2812         */
2813        select(button?: any): void;
2814        triggerChange(): void;
2815        /**
2816         * @param button
2817         */
2818        unselect(button?: any): void;
2819    }
2820}
2821declare namespace PrimeFaces.widget {
2822    /**
2823     * PrimeFaces SelectOneListbox Widget
2824     */
2825    export class SelectOneListbox extends PrimeFaces.widget.SelectListbox {
2826        bindEvents(): void;
2827        bindKeyEvents(): void;
2828        removeOutline(): void;
2829    }
2830}
2831declare namespace PrimeFaces.widget {
2832    /**
2833     * PrimeFaces SelectOneMenu Widget
2834     */
2835    export class SelectOneMenu extends PrimeFaces.widget.DeferredWidget<PrimeFaces.widget.DeferredWidgetCfg> {
2836        alignPanel(): void;
2837        alignPanelWidth(): void;
2838        bindConstantEvents(): void;
2839        bindEvents(): void;
2840        bindFilterEvents(): void;
2841        bindItemEvents(): void;
2842        bindKeyEvents(): void;
2843        blur(): void;
2844        /**
2845         * @param handleMethod
2846         * @param event
2847         */
2848        callHandleMethod(handleMethod?: any, event?: any): void;
2849        /**
2850         * @param item
2851         */
2852        changeAriaValue(item?: any): void;
2853        /**
2854         * @param value
2855         * @param filter
2856         * @return
2857         */
2858        containsFilter(value?: any, filter?: any): any;
2859        disable(): void;
2860        dynamicPanelLoad(): void;
2861        enable(): void;
2862        /**
2863         * @param value
2864         * @param filter
2865         * @return
2866         */
2867        endsWithFilter(value?: any, filter?: any): any;
2868        /**
2869         * @param value
2870         */
2871        filter(value?: any): void;
2872        focus(): void;
2873        /**
2874         * @param timeout
2875         */
2876        focusFilter(timeout?: any): void;
2877        /**
2878         * @return
2879         */
2880        getActiveItem(): any;
2881        /**
2882         * @return
2883         */
2884        getAppendTo(): any;
2885        /**
2886         * @param value
2887         * @return
2888         */
2889        getLabelToDisplay(value?: any): any;
2890        /**
2891         * @return
2892         */
2893        getSelectedLabel(): any;
2894        /**
2895         * @return
2896         */
2897        getSelectedValue(): any;
2898        /**
2899         * @param event
2900         */
2901        handleEnterKey(event?: any): void;
2902        /**
2903         * @param event
2904         */
2905        handleEscapeKey(event?: any): void;
2906        /**
2907         * @param event
2908         */
2909        handleLabelChange(event?: any): void;
2910        /**
2911         * @param event
2912         */
2913        handleSpaceKey(event?: any): void;
2914        handleTabKey(): void;
2915        hide(): void;
2916        /**
2917         * @param item
2918         */
2919        highlightItem(item?: any): void;
2920        /**
2921         * @param event
2922         */
2923        highlightNext(event?: any): void;
2924        /**
2925         * @param event
2926         */
2927        highlightPrev(event?: any): void;
2928        /**
2929         * @param cfg
2930         */
2931        init(cfg?: any): void;
2932        initContents(): void;
2933        /**
2934         * @param text
2935         * @return
2936         */
2937        matchOptions(text?: any): any;
2938        /**
2939         * @param cfg
2940         */
2941        refresh(cfg?: any): void;
2942        /**
2943         * @param item
2944         * @return
2945         */
2946        resolveItemIndex(item?: any): any;
2947        revert(): void;
2948        /**
2949         * Handler to process item selection with mouse
2950         *
2951         * @param item
2952         * @param silent
2953         */
2954        selectItem(item?: any, silent?: any): void;
2955        /**
2956         * @param value
2957         */
2958        selectValue(value?: any): void;
2959        /**
2960         * @param value
2961         */
2962        setLabel(value?: any): void;
2963        setupFilterMatcher(): void;
2964        show(): void;
2965        /**
2966         * @param value
2967         * @param filter
2968         * @return
2969         */
2970        startsWithFilter(value?: any, filter?: any): any;
2971        /**
2972         * @param option
2973         */
2974        syncTitle(option?: any): void;
2975        /**
2976         * @param edited
2977         */
2978        triggerChange(edited?: any): void;
2979        unbindEvents(): void;
2980        /**
2981         * @param add
2982         */
2983        updatePlaceholderClass(add?: any): void;
2984    }
2985}
2986declare namespace PrimeFaces.widget {
2987    /**
2988     * PrimeFaces SelectOneRadio Widget
2989     */
2990    export class SelectOneRadio extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
2991        bindEvents(): void;
2992        /**
2993         * @param index
2994         */
2995        disable(index?: any): void;
2996        /**
2997         * @param index
2998         */
2999        enable(index?: any): void;
3000        /**
3001         * @param input
3002         * @param event
3003         */
3004        fireClickEvent(input?: any, event?: any): void;
3005        /**
3006         * @param cfg
3007         */
3008        init(cfg?: any): void;
3009        /**
3010         * @param cfg
3011         */
3012        refresh(cfg?: any): void;
3013        /**
3014         * @param radio
3015         */
3016        select(radio?: any): void;
3017        /**
3018         * @param input
3019         */
3020        unbindEvents(input?: any): void;
3021        /**
3022         * @param radio
3023         */
3024        unselect(radio?: any): void;
3025    }
3026}
3027declare namespace PrimeFaces.widget {
3028    /**
3029     * PrimeFaces SplitButton Widget
3030     */
3031    export class SplitButton extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
3032        alignPanel(): void;
3033        bindEvents(): void;
3034        bindFilterEvents(): void;
3035        /**
3036         * @param value
3037         * @param filter
3038         * @return
3039         */
3040        containsFilter(value?: any, filter?: any): any;
3041        /**
3042         * @param value
3043         * @param filter
3044         * @return
3045         */
3046        endsWithFilter(value?: any, filter?: any): any;
3047        /**
3048         * @param value
3049         */
3050        filter(value?: any): void;
3051        /**
3052         * @param event
3053         */
3054        handleEnterKey(event?: any): void;
3055        handleEscapeKey(): void;
3056        hide(): void;
3057        /**
3058         * @param event
3059         */
3060        highlightNext(event?: any): void;
3061        /**
3062         * @param event
3063         */
3064        highlightPrev(event?: any): void;
3065        /**
3066         * @param cfg
3067         */
3068        init(cfg?: any): void;
3069        /**
3070         * @param cfg
3071         */
3072        refresh(cfg?: any): void;
3073        setupFilterMatcher(): void;
3074        show(): void;
3075        /**
3076         * @param value
3077         * @param filter
3078         * @return
3079         */
3080        startsWithFilter(value?: any, filter?: any): any;
3081    }
3082}
3083declare namespace PrimeFaces.widget {
3084    /**
3085     * PrimeFaces ThemeSwitcher Widget
3086     */
3087    export class ThemeSwitcher extends PrimeFaces.widget.SelectOneMenu {
3088        /**
3089         * @param cfg
3090         */
3091        init(cfg?: any): void;
3092    }
3093}
3094declare namespace PrimeFaces.widget {
3095    /**
3096     * PrimeFaces Galleria Widget
3097     */
3098    export class Galleria extends PrimeFaces.widget.DeferredWidget<PrimeFaces.widget.DeferredWidgetCfg> {
3099        bindEvents(): void;
3100        hideCaption(): void;
3101        /**
3102         * @param cfg
3103         */
3104        init(cfg?: any): void;
3105        /**
3106         * @return
3107         */
3108        isAnimating(): any;
3109        /**
3110         * @return
3111         */
3112        isSlideshowActive(): any;
3113        next(): void;
3114        prev(): void;
3115        renderStrip(): void;
3116        /**
3117         * @param index
3118         * @param reposition
3119         */
3120        select(index?: any, reposition?: any): void;
3121        /**
3122         * @param panel
3123         */
3124        showCaption(panel?: any): void;
3125        startSlideshow(): void;
3126        stopSlideshow(): void;
3127    }
3128}
3129declare namespace PrimeFaces.widget {
3130    /**
3131     * PrimeFaces Google Maps Widget
3132     */
3133    export class GMap extends PrimeFaces.widget.DeferredWidget<PrimeFaces.widget.DeferredWidgetCfg> {
3134        /**
3135         * @param overlay
3136         */
3137        addOverlay(overlay?: any): void;
3138        /**
3139         * @param overlays
3140         */
3141        addOverlays(overlays?: any): void;
3142        checkResize(): void;
3143        configureCircles(): void;
3144        configureEventListeners(): void;
3145        configureMarkers(): void;
3146        configurePointSelectListener(): void;
3147        configurePolygons(): void;
3148        configurePolylines(): void;
3149        configureRectangles(): void;
3150        configureStateChangeListener(): void;
3151        /**
3152         * @param overlay
3153         */
3154        extendView(overlay?: any): void;
3155        /**
3156         * @param event
3157         * @param marker
3158         */
3159        fireMarkerDragEvent(event?: any, marker?: any): void;
3160        /**
3161         * @param event
3162         * @param overlay
3163         */
3164        fireOverlaySelectEvent(event?: any, overlay?: any): void;
3165        /**
3166         * @param event
3167         */
3168        firePointSelectEvent(event?: any): void;
3169        /**
3170         * @param event
3171         */
3172        fireStateChangeEvent(event?: any): void;
3173        /**
3174         * @param address
3175         */
3176        geocode(address?: any): void;
3177        /**
3178         * @return
3179         */
3180        getInfoWindow(): any;
3181        /**
3182         * @return
3183         */
3184        getMap(): any;
3185        /**
3186         * @param cfg
3187         */
3188        init(cfg?: any): void;
3189        /**
3190         * @param content
3191         */
3192        loadWindow(content?: any): void;
3193        /**
3194         * @param responseXML
3195         * @return
3196         */
3197        openWindow(responseXML?: any): any;
3198        /**
3199         * @param lat
3200         * @param lng
3201         */
3202        reverseGeocode(lat?: any, lng?: any): void;
3203    }
3204}
3205declare namespace PrimeFaces.widget {
3206    /**
3207     * PrimeFaces Growl Widget
3208     */
3209    export class Growl extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
3210        /**
3211         * @param message
3212         */
3213        bindEvents(message?: any): void;
3214        /**
3215         * @param cfg
3216         */
3217        init(cfg?: any): void;
3218        /**
3219         * @param cfg
3220         */
3221        refresh(cfg?: any): void;
3222        removeAll(): void;
3223        /**
3224         * @param message
3225         */
3226        removeMessage(message?: any): void;
3227        render(): void;
3228        /**
3229         * @param msg
3230         */
3231        renderMessage(msg?: any): void;
3232        /**
3233         * @param message
3234         */
3235        setRemovalTimeout(message?: any): void;
3236        /**
3237         * @param msgs
3238         */
3239        show(msgs?: any): void;
3240    }
3241}
3242declare namespace PrimeFaces.widget {
3243    /**
3244     * PrimeFaces IdleMonitor Widget
3245     */
3246    export class IdleMonitor extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
3247        destroy(): void;
3248        /**
3249         * @param cfg
3250         */
3251        init(cfg?: any): void;
3252        pause(): void;
3253        reset(): void;
3254        resume(): void;
3255    }
3256}
3257declare namespace PrimeFaces.widget {
3258    /**
3259     * PrimeFaces ImageCompare Widget
3260     */
3261    export class ImageCompare extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
3262        /**
3263         * @param cfg
3264         */
3265        init(cfg?: any): void;
3266    }
3267}
3268declare namespace PrimeFaces.widget {
3269    /**
3270     * PrimeFaces ImageCropper Widget
3271     */
3272    export class ImageCropper extends PrimeFaces.widget.DeferredWidget<PrimeFaces.widget.DeferredWidgetCfg> {
3273        /**
3274         * @param cfg
3275         */
3276        init(cfg?: any): void;
3277        /**
3278         * @param c
3279         */
3280        saveCoords(c?: any): void;
3281    }
3282}
3283declare namespace PrimeFaces.widget {
3284    /**
3285     * PrimeFaces ImageSwitch Widget
3286     */
3287    export class ImageSwitch extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
3288        /**
3289         * @param cfg
3290         */
3291        init(cfg?: any): void;
3292        next(): void;
3293        pauseSlideshow(): void;
3294        previous(): void;
3295        resumeSlideshow(): void;
3296        stopSlideshow(): void;
3297        /**
3298         * @param index
3299         */
3300        switchTo(index?: any): void;
3301        toggleSlideshow(): void;
3302    }
3303}
3304declare namespace PrimeFaces.widget {
3305    /**
3306     * PrimeFaces Inplace Widget
3307     */
3308    export class Inplace extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
3309        /**
3310         * @param e
3311         */
3312        cancel(e?: any): void;
3313        /**
3314         * @return
3315         */
3316        getContent(): any;
3317        /**
3318         * @return
3319         */
3320        getDisplay(): any;
3321        hide(): void;
3322        /**
3323         * @param cfg
3324         */
3325        init(cfg?: any): void;
3326        postShow(): void;
3327        /**
3328         * @param e
3329         */
3330        save(e?: any): void;
3331        show(): void;
3332        /**
3333         * @param elToShow
3334         * @param elToHide
3335         */
3336        toggle(elToShow?: any, elToHide?: any): void;
3337    }
3338}
3339declare namespace PrimeFaces.widget {
3340    export class InputNumber extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
3341        /**
3342         * @return
3343         */
3344        copyValueToHiddenInput(): any;
3345        disable(): void;
3346        enable(): void;
3347        /**
3348         * @return
3349         */
3350        getValue(): any;
3351        /**
3352         * Initializes the widget.
3353         *
3354         * @param cfg The widget configuration.
3355         */
3356        init(cfg: object): void;
3357        /**
3358         * @param value
3359         */
3360        setValue(value?: any): void;
3361        /**
3362         * @param value
3363         */
3364        setValueToHiddenInput(value?: any): void;
3365        /**
3366         * Wraps the events on the external (visible) input to copy the value to the hidden input,
3367         * before calling the callback.
3368         */
3369        wrapEvents(): void;
3370    }
3371}
3372declare namespace PrimeFaces.widget {
3373    /**
3374     * PrimeFaces InputSwitch Widget
3375     */
3376    export class InputSwitch extends PrimeFaces.widget.DeferredWidget<PrimeFaces.widget.DeferredWidgetCfg> {
3377        check(): void;
3378        /**
3379         * @param cfg
3380         */
3381        init(cfg?: any): void;
3382        toggle(): void;
3383        uncheck(): void;
3384    }
3385}
3386declare namespace PrimeFaces.widget {
3387    /**
3388     * PrimeFaces Keyboard Widget
3389     */
3390    export class Keyboard extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
3391        /**
3392         * @param cfg
3393         */
3394        init(cfg?: any): void;
3395    }
3396}
3397declare namespace PrimeFaces.widget {
3398    export class KeyFilter extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
3399        /**
3400         * Initializes the widget.
3401         *
3402         * @param cfg The widget configuration.
3403         */
3404        init(cfg: object): void;
3405    }
3406}
3407declare namespace PrimeFaces.widget {
3408    export class Knob extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
3409        createKnob(): void;
3410        decrement(): void;
3411        /**
3412         * @return
3413         */
3414        getValue(): any;
3415        increment(): void;
3416        /**
3417         * @param cfg
3418         */
3419        init(cfg?: any): void;
3420        /**
3421         * @param cfg
3422         */
3423        refresh(cfg?: any): void;
3424        /**
3425         * @param value
3426         */
3427        setValue(value?: any): void;
3428    }
3429}
3430declare namespace PrimeFaces.widget {
3431    /**
3432     * PrimeFaces Layout Widget
3433     */
3434    export class Layout extends PrimeFaces.widget.DeferredWidget<PrimeFaces.widget.DeferredWidgetCfg> {
3435        bindEvents(): void;
3436        /**
3437         * @param location
3438         * @param collapsed
3439         */
3440        fireToggleEvent(location?: any, collapsed?: any): void;
3441        /**
3442         * @param location
3443         */
3444        hide(location?: any): void;
3445        /**
3446         * @param cfg
3447         */
3448        init(cfg?: any): void;
3449        /**
3450         * @param location
3451         * @param pane
3452         * @param state
3453         */
3454        onclose(location?: any, pane?: any, state?: any): void;
3455        /**
3456         * @param location
3457         * @param pane
3458         * @param state
3459         */
3460        onhide(location?: any, pane?: any, state?: any): void;
3461        /**
3462         * @param location
3463         * @param pane
3464         * @param state
3465         */
3466        onopen(location?: any, pane?: any, state?: any): void;
3467        /**
3468         * @param location
3469         * @param pane
3470         * @param state
3471         */
3472        onresize(location?: any, pane?: any, state?: any): void;
3473        /**
3474         * @param location
3475         * @param pane
3476         * @param state
3477         */
3478        onshow(location?: any, pane?: any, state?: any): void;
3479        /**
3480         * @param location
3481         */
3482        show(location?: any): void;
3483        /**
3484         * @param location
3485         */
3486        toggle(location?: any): void;
3487    }
3488}
3489declare namespace PrimeFaces.widget {
3490    export class Lifecycle extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
3491        /**
3492         * @param cfg
3493         */
3494        init(cfg?: any): void;
3495        update(): void;
3496    }
3497}
3498declare namespace PrimeFaces.widget {
3499    /**
3500     * PrimeFaces LightBox Widget
3501     */
3502    export class LightBox extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
3503        /**
3504         * @param fn
3505         */
3506        addOnshowHandler(fn?: any): void;
3507        bindCommonEvents(): void;
3508        center(): void;
3509        createPanel(): void;
3510        disableModality(): void;
3511        enableModality(): void;
3512        hide(): void;
3513        hideNavigators(): void;
3514        /**
3515         * @param cfg
3516         */
3517        init(cfg?: any): void;
3518        /**
3519         * @return
3520         */
3521        isHidden(): any;
3522        /**
3523         * @param cfg
3524         */
3525        refresh(cfg?: any): void;
3526        /**
3527         * @param image
3528         */
3529        scaleImage(image?: any): void;
3530        setupIframe(): void;
3531        setupImaging(): void;
3532        setupInline(): void;
3533        show(): void;
3534        showNavigators(): void;
3535        /**
3536         * @param opt
3537         */
3538        showURL(opt?: any): void;
3539    }
3540}
3541declare namespace PrimeFaces.widget {
3542    /**
3543     * PrimeFaces Log Widget
3544     */
3545    export class Log extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
3546        /**
3547         * @param msg
3548         * @param severity
3549         * @param icon
3550         */
3551        add(msg?: any, severity?: any, icon?: any): void;
3552        bindEvents(): void;
3553        /**
3554         * @param msg
3555         */
3556        debug(msg?: any): void;
3557        /**
3558         * @param msg
3559         */
3560        error(msg?: any): void;
3561        /**
3562         * @param severity
3563         */
3564        filter(severity?: any): void;
3565        /**
3566         * @param event
3567         * @param severityClass
3568         * @param severity
3569         * @param button
3570         */
3571        handleFilterClick(event?: any, severityClass?: any, severity?: any, button?: any): void;
3572        hide(): void;
3573        /**
3574         * @param msg
3575         */
3576        info(msg?: any): void;
3577        /**
3578         * @param cfg
3579         */
3580        init(cfg?: any): void;
3581        show(): void;
3582        /**
3583         * @param msg
3584         */
3585        warn(msg?: any): void;
3586    }
3587}
3588declare namespace PrimeFaces.widget {
3589    export class Menu extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
3590        align(): void;
3591        hide(): void;
3592        /**
3593         * @param cfg
3594         */
3595        init(cfg?: any): void;
3596        initOverlay(): void;
3597        setupDialogSupport(): void;
3598        show(): void;
3599    }
3600}
3601declare namespace PrimeFaces.widget {
3602    export class ContextMenu extends PrimeFaces.widget.TieredMenu {
3603        bindItemEvents(): void;
3604        /**
3605         * @return
3606         */
3607        getTarget(): any;
3608        hide(): void;
3609        /**
3610         * @param cfg
3611         */
3612        init(cfg?: any): void;
3613        /**
3614         * @return
3615         */
3616        isVisible(): any;
3617        /**
3618         * @param e
3619         */
3620        show(e?: any): void;
3621    }
3622}
3623declare namespace PrimeFaces.widget {
3624    export class MegaMenu extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
3625        /**
3626         * @param menuitem
3627         */
3628        activate(menuitem?: any): void;
3629        bindEvents(): void;
3630        bindKeyEvents(): void;
3631        /**
3632         * @param menuitem
3633         * @param animate
3634         */
3635        deactivate(menuitem?: any, animate?: any): void;
3636        /**
3637         * @param menuitem
3638         * @return
3639         */
3640        findNextItem(menuitem?: any): any;
3641        /**
3642         * @param menuitem
3643         * @return
3644         */
3645        findPrevItem(menuitem?: any): any;
3646        /**
3647         * @param submenu
3648         * @return
3649         */
3650        getFirstMenuList(submenu?: any): any;
3651        /**
3652         * @param menuitem
3653         */
3654        highlight(menuitem?: any): void;
3655        /**
3656         * @param cfg
3657         */
3658        init(cfg?: any): void;
3659        /**
3660         * @param menuitem
3661         * @return
3662         */
3663        isRootLink(menuitem?: any): any;
3664        reset(): void;
3665        /**
3666         * @param menuitem
3667         * @param submenu
3668         */
3669        showSubmenu(menuitem?: any, submenu?: any): void;
3670    }
3671}
3672declare namespace PrimeFaces.widget {
3673    export class Menubar extends PrimeFaces.widget.TieredMenu {
3674        bindKeyEvents(): void;
3675        /**
3676         * @param menuitem
3677         * @param submenu
3678         */
3679        showSubmenu(menuitem?: any, submenu?: any): void;
3680    }
3681}
3682declare namespace PrimeFaces.widget {
3683    export class MenuButton extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
3684        alignPanel(): void;
3685        bindEvents(): void;
3686        hide(): void;
3687        /**
3688         * @param cfg
3689         */
3690        init(cfg?: any): void;
3691        /**
3692         * @param cfg
3693         */
3694        refresh(cfg?: any): void;
3695        show(): void;
3696    }
3697}
3698declare namespace PrimeFaces.widget {
3699    export class PanelMenu extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
3700        /**
3701         * @param element
3702         */
3703        addAsExpanded(element?: any): void;
3704        bindEvents(): void;
3705        bindKeyEvents(): void;
3706        clearState(): void;
3707        /**
3708         * @param header
3709         */
3710        collapseActiveSibling(header?: any): void;
3711        collapseAll(): void;
3712        /**
3713         * @param header
3714         */
3715        collapseRootSubmenu(header?: any): void;
3716        /**
3717         * @param submenu
3718         */
3719        collapseTreeItem(submenu?: any): void;
3720        /**
3721         * @param header
3722         * @param restoring
3723         */
3724        expandRootSubmenu(header?: any, restoring?: any): void;
3725        /**
3726         * @param submenu
3727         * @param restoring
3728         */
3729        expandTreeItem(submenu?: any, restoring?: any): void;
3730        /**
3731         * @param item
3732         */
3733        focusItem(item?: any): void;
3734        /**
3735         * @param content
3736         * @return
3737         */
3738        getFirstItemOfContent(content?: any): any;
3739        /**
3740         * @param item
3741         * @return
3742         */
3743        getItemText(item?: any): any;
3744        /**
3745         * @param cfg
3746         */
3747        init(cfg?: any): void;
3748        /**
3749         * @param item
3750         * @return
3751         */
3752        isExpanded(item?: any): any;
3753        /**
3754         * @param element
3755         */
3756        removeAsExpanded(element?: any): void;
3757        removeFocusedItem(): void;
3758        restoreState(): void;
3759        saveState(): void;
3760        /**
3761         * @param item
3762         * @return
3763         */
3764        searchDown(item?: any): any;
3765    }
3766}
3767declare namespace PrimeFaces.widget {
3768    export class PlainMenu extends PrimeFaces.widget.Menu {
3769        bindEvents(): void;
3770        clearState(): void;
3771        /**
3772         * @param header
3773         * @param stateful
3774         */
3775        collapseSubmenu(header?: any, stateful?: any): void;
3776        /**
3777         * @param header
3778         * @param stateful
3779         */
3780        expandSubmenu(header?: any, stateful?: any): void;
3781        /**
3782         * @param cfg
3783         */
3784        init(cfg?: any): void;
3785        restoreState(): void;
3786        saveState(): void;
3787    }
3788}
3789declare namespace PrimeFaces.widget {
3790    export class SlideMenu extends PrimeFaces.widget.Menu {
3791        back(): void;
3792        bindEvents(): void;
3793        /**
3794         * @return
3795         */
3796        depth(): any;
3797        /**
3798         * @param submenu
3799         */
3800        forward(submenu?: any): void;
3801        /**
3802         * @param cfg
3803         */
3804        init(cfg?: any): void;
3805        /**
3806         * @return
3807         */
3808        last(): any;
3809        /**
3810         * @return
3811         */
3812        pop(): any;
3813        /**
3814         * @param submenu
3815         */
3816        push(submenu?: any): void;
3817        render(): void;
3818        show(): void;
3819    }
3820}
3821declare namespace PrimeFaces.widget {
3822    export class TabMenu extends PrimeFaces.widget.Menu {
3823        bindEvents(): void;
3824        bindKeyEvents(): void;
3825        /**
3826         * @param cfg
3827         */
3828        init(cfg?: any): void;
3829    }
3830}
3831declare namespace PrimeFaces.widget {
3832    export class TieredMenu extends PrimeFaces.widget.Menu {
3833        /**
3834         * @param menuitem
3835         */
3836        activate(menuitem?: any): void;
3837        bindClickModeEvents(): void;
3838        bindDocumentHandler(): void;
3839        bindEvents(): void;
3840        bindHoverModeEvents(): void;
3841        bindItemEvents(): void;
3842        bindKeyEvents(): void;
3843        /**
3844         * @param menuitem
3845         * @param animate
3846         */
3847        deactivate(menuitem?: any, animate?: any): void;
3848        /**
3849         * @param menuitem
3850         */
3851        highlight(menuitem?: any): void;
3852        /**
3853         * @param cfg
3854         */
3855        init(cfg?: any): void;
3856        /**
3857         * @param menuitem
3858         */
3859        reactivate(menuitem?: any): void;
3860        reset(): void;
3861        /**
3862         * @param menuitem
3863         * @param submenu
3864         */
3865        showSubmenu(menuitem?: any, submenu?: any): void;
3866    }
3867}
3868declare namespace PrimeFaces.widget {
3869    /**
3870     * PrimeFaces Message Widget
3871     */
3872    export class Message extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
3873        /**
3874         * @param cfg
3875         */
3876        init(cfg?: any): void;
3877    }
3878}
3879declare namespace PrimeFaces.widget {
3880    /**
3881     * PrimeFaces Mindmap Widget
3882     */
3883    export class Mindmap extends PrimeFaces.widget.DeferredWidget<PrimeFaces.widget.DeferredWidgetCfg> {
3884        /**
3885         * @param node
3886         */
3887        centerNode(node?: any): void;
3888        clickNode(): void;
3889        clickNodeText(): void;
3890        /**
3891         * @param x
3892         * @param y
3893         * @param model
3894         * @return
3895         */
3896        createNode(x?: any, y?: any, model?: any): any;
3897        /**
3898         * @param node
3899         */
3900        createSubNodes(node?: any): void;
3901        /**
3902         * @param node
3903         */
3904        expandNode(node?: any): void;
3905        /**
3906         * @param node
3907         */
3908        handleDblclickNode(node?: any): void;
3909        /**
3910         * @param node
3911         */
3912        handleNodeClick(node?: any): void;
3913        /**
3914         * @param node
3915         */
3916        hideTooltip(node?: any): void;
3917        /**
3918         * @param cfg
3919         */
3920        init(cfg?: any): void;
3921        mouseoutNode(): void;
3922        mouseoutText(): void;
3923        mouseoverNode(): void;
3924        mouseoverText(): void;
3925        /**
3926         * @param dx
3927         * @param dy
3928         */
3929        nodeDrag(dx?: any, dy?: any): void;
3930        nodeDragEnd(): void;
3931        nodeDragStart(): void;
3932        /**
3933         * @param node
3934         */
3935        removeNode(node?: any): void;
3936        /**
3937         * @param node
3938         */
3939        showTooltip(node?: any): void;
3940        /**
3941         * @param dx
3942         * @param dy
3943         */
3944        textDrag(dx?: any, dy?: any): void;
3945        textDragEnd(): void;
3946        textDragStart(): void;
3947        /**
3948         * @param node
3949         */
3950        updateConnections(node?: any): void;
3951    }
3952}
3953declare namespace PrimeFaces.widget {
3954    /**
3955     * PrimeFaces NotificationBar Widget
3956     */
3957    export class NotificationBar extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
3958        hide(): void;
3959        /**
3960         * @param cfg
3961         */
3962        init(cfg?: any): void;
3963        /**
3964         * @return
3965         */
3966        isVisible(): any;
3967        /**
3968         * The up-to-three arguments will be routed to jQuery as it is.
3969         *
3970         * @param a1
3971         * @param a2
3972         * @param a3
3973         */
3974        show(a1?: any, a2?: any, a3?: any): void;
3975        toggle(): void;
3976    }
3977}
3978declare namespace PrimeFaces.widget {
3979    /**
3980     * PrimeFaces OrderList Widget
3981     */
3982    export class OrderList extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
3983        bindEvents(): void;
3984        /**
3985         * @param item
3986         * @param e
3987         */
3988        fireItemSelectEvent(item?: any, e?: any): void;
3989        /**
3990         * @param item
3991         */
3992        fireItemUnselectEvent(item?: any): void;
3993        fireReorderEvent(): void;
3994        generateItems(): void;
3995        /**
3996         * @param cfg
3997         */
3998        init(cfg?: any): void;
3999        moveBottom(): void;
4000        moveDown(): void;
4001        moveTop(): void;
4002        moveUp(): void;
4003        /**
4004         * @param event
4005         * @param ui
4006         */
4007        onDragDrop(event?: any, ui?: any): void;
4008        saveState(): void;
4009        setupButtons(): void;
4010    }
4011}
4012declare namespace PrimeFaces.widget {
4013    export class Organigram extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
4014        /**
4015         * @param nodeSource
4016         * @param node
4017         * @param bottomIconContainer
4018         */
4019        addExpander(nodeSource?: any, node?: any, bottomIconContainer?: any): void;
4020        /**
4021         * @param menuWidget
4022         * @param targetWidget
4023         * @param targetId
4024         * @param cfg
4025         */
4026        bindContextMenu(menuWidget?: any, targetWidget?: any, targetId?: any, cfg?: any): void;
4027        draw(): void;
4028        /**
4029         * @param parentRowKey
4030         * @param leafChildNodes
4031         * @param nonLeafChildNodes
4032         * @param table
4033         * @param level
4034         */
4035        drawChildNodes(parentRowKey?: any, leafChildNodes?: any, nonLeafChildNodes?: any, table?: any, level?: any): void;
4036        /**
4037         * @param childNodeCount
4038         * @param table
4039         */
4040        drawLines(childNodeCount?: any, table?: any): void;
4041        /**
4042         * @param parentRowKey
4043         * @param nodeSource
4044         * @param appendTo
4045         * @param level
4046         */
4047        drawNode(parentRowKey?: any, nodeSource?: any, appendTo?: any, level?: any): void;
4048        /**
4049         * @param cfg
4050         */
4051        init(cfg?: any): void;
4052        scrollToSelection(): void;
4053        /**
4054         * @param widget
4055         * @param node
4056         * @param event
4057         */
4058        selectNode(widget?: any, node?: any, event?: any): void;
4059        /**
4060         * Setup global controls.
4061         * Currently zoom-in and zoom-out.
4062         */
4063        setupControls(): void;
4064        setupDragAndDrop(): void;
4065        setupSelection(): void;
4066        /**
4067         * Applies css zoom/scale to the target DOM.
4068         *
4069         * @param zoom The zoom factor. (e.g. 1.0 or 0.5)
4070         */
4071        zoom(zoom: number): void;
4072    }
4073}
4074declare namespace PrimeFaces.widget {
4075    /**
4076     * PrimeFaces OutputPanel Widget
4077     */
4078    export class OutputPanel extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
4079        bindScrollMonitor(): void;
4080        /**
4081         * @param cfg
4082         */
4083        init(cfg?: any): void;
4084        loadContent(): void;
4085        /**
4086         * @return
4087         */
4088        visible(): any;
4089    }
4090}
4091declare namespace PrimeFaces.widget {
4092    /**
4093     * PrimeFaces OverlayPanel Widget
4094     */
4095    export class OverlayPanel extends PrimeFaces.widget.DynamicOverlayWidget {
4096        /**
4097         * @param target
4098         */
4099        align(target?: any): void;
4100        applyFocus(): void;
4101        bindCommonEvents(): void;
4102        bindTargetEvents(): void;
4103        destroy(): void;
4104        disableModality(): void;
4105        enableModality(): void;
4106        /**
4107         * @return
4108         */
4109        getModalTabbables(): any;
4110        hide(): void;
4111        /**
4112         * @param cfg
4113         */
4114        init(cfg?: any): void;
4115        /**
4116         * @return
4117         */
4118        isVisible(): any;
4119        /**
4120         * @param target
4121         */
4122        loadContents(target?: any): void;
4123        postHide(): void;
4124        postShow(): void;
4125        /**
4126         * @param cfg
4127         */
4128        refresh(cfg?: any): void;
4129        setupDialogSupport(): void;
4130        /**
4131         * @param target
4132         */
4133        show(target?: any): void;
4134        toggle(): void;
4135    }
4136}
4137declare namespace PrimeFaces.widget {
4138    export class Paginator extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
4139        bindEvents(): void;
4140        bindPageLinkEvents(): void;
4141        /**
4142         * @param element
4143         */
4144        disableElement(element?: any): void;
4145        /**
4146         * @param element
4147         */
4148        enableElement(element?: any): void;
4149        /**
4150         * @param margin
4151         * @return
4152         */
4153        getContainerHeight(margin?: any): any;
4154        /**
4155         * @return
4156         */
4157        getCurrentPage(): any;
4158        /**
4159         * @return
4160         */
4161        getFirst(): any;
4162        /**
4163         * @return
4164         */
4165        getRows(): any;
4166        /**
4167         * @param cfg
4168         */
4169        init(cfg?: any): void;
4170        next(): void;
4171        prev(): void;
4172        /**
4173         * @param p
4174         * @param silent
4175         */
4176        setPage(p?: any, silent?: any): void;
4177        /**
4178         * @param rpp
4179         */
4180        setRowsPerPage(rpp?: any): void;
4181        /**
4182         * @param value
4183         */
4184        setTotalRecords(value?: any): void;
4185        unbindEvents(): void;
4186        updatePageLinks(): void;
4187        /**
4188         * @param value
4189         */
4190        updateTotalRecords(value?: any): void;
4191        updateUI(): void;
4192    }
4193}
4194declare namespace PrimeFaces.widget {
4195    /**
4196     * PrimeFaces Panel Widget
4197     */
4198    export class Panel extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
4199        bindCloser(): void;
4200        bindEvents(): void;
4201        bindToggler(): void;
4202        close(): void;
4203        collapse(): void;
4204        expand(): void;
4205        /**
4206         * @param cfg
4207         */
4208        init(cfg?: any): void;
4209        show(): void;
4210        slideDown(): void;
4211        slideLeft(): void;
4212        slideRight(): void;
4213        slideUp(): void;
4214        toggle(): void;
4215        /**
4216         * @param collapsed
4217         * @param removeIcon
4218         * @param addIcon
4219         */
4220        toggleState(collapsed?: any, removeIcon?: any, addIcon?: any): void;
4221    }
4222}
4223declare namespace PrimeFaces.widget {
4224    /**
4225     * PrimeFaces PhotoCam Widget
4226     */
4227    export class PhotoCam extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
4228        attached: any;
4229        attach(): void;
4230        capture(): void;
4231        destroy(): void;
4232        dettach(): void;
4233        /**
4234         * @param cfg
4235         */
4236        init(cfg?: any): void;
4237    }
4238}
4239declare namespace PrimeFaces.widget {
4240    /**
4241     * PrimeFaces PickList Widget
4242     */
4243    export class PickList extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
4244        add(): void;
4245        addAll(): void;
4246        bindButtonEvents(): void;
4247        /**
4248         * @param filter
4249         */
4250        bindEnterKeyFilter(filter?: any): void;
4251        /**
4252         * @param filter
4253         */
4254        bindFilterEvent(filter?: any): void;
4255        bindFilterEvents(): void;
4256        bindItemEvents(): void;
4257        bindKeyEvents(): void;
4258        /**
4259         * @param filter
4260         */
4261        bindTextFilter(filter?: any): void;
4262        /**
4263         * @param e
4264         */
4265        blockEnterKey(e?: any): void;
4266        /**
4267         * @param value
4268         * @param filter
4269         * @return
4270         */
4271        containsFilter(value?: any, filter?: any): any;
4272        /**
4273         * @param button
4274         */
4275        disableButton(button?: any): void;
4276        /**
4277         * @param button
4278         */
4279        enableButton(button?: any): void;
4280        /**
4281         * @param value
4282         * @param filter
4283         * @return
4284         */
4285        endsWithFilter(value?: any, filter?: any): any;
4286        /**
4287         * @param value
4288         * @param list
4289         */
4290        filter(value?: any, list?: any): void;
4291        /**
4292         * @param item
4293         */
4294        fireItemSelectEvent(item?: any): void;
4295        /**
4296         * @param item
4297         */
4298        fireItemUnselectEvent(item?: any): void;
4299        fireReorderEvent(): void;
4300        /**
4301         * Fire transfer ajax behavior event
4302         *
4303         * @param items
4304         * @param from
4305         * @param to
4306         * @param type
4307         */
4308        fireTransferEvent(items?: any, from?: any, to?: any, type?: any): void;
4309        /**
4310         * @param list
4311         * @param input
4312         */
4313        generateItems(list?: any, input?: any): void;
4314        /**
4315         * @param filter
4316         * @return
4317         */
4318        getFilteredList(filter?: any): any;
4319        /**
4320         * @param element
4321         * @return
4322         */
4323        getListName(element?: any): any;
4324        /**
4325         * @return
4326         */
4327        getTabIndex(): any;
4328        /**
4329         * @param cfg
4330         */
4331        init(cfg?: any): void;
4332        /**
4333         * @return
4334         */
4335        isAnimated(): any;
4336        /**
4337         * @param list
4338         */
4339        moveBottom(list?: any): void;
4340        /**
4341         * @param list
4342         */
4343        moveDown(list?: any): void;
4344        /**
4345         * @param list
4346         */
4347        moveTop(list?: any): void;
4348        /**
4349         * @param list
4350         */
4351        moveUp(list?: any): void;
4352        remove(): void;
4353        removeAll(): void;
4354        removeOutline(): void;
4355        /**
4356         * Clear inputs and repopulate them from the list states
4357         */
4358        saveState(): void;
4359        /**
4360         * @param chkbox
4361         */
4362        selectCheckbox(chkbox?: any): void;
4363        /**
4364         * @param item
4365         * @param silent
4366         */
4367        selectItem(item?: any, silent?: any): void;
4368        setTabIndex(): void;
4369        setupFilterMatcher(): void;
4370        /**
4371         * @param value
4372         * @param filter
4373         * @return
4374         */
4375        startsWithFilter(value?: any, filter?: any): any;
4376        /**
4377         * @param items
4378         * @param from
4379         * @param to
4380         * @param type
4381         */
4382        transfer(items?: any, from?: any, to?: any, type?: any): void;
4383        unselectAll(): void;
4384        /**
4385         * @param chkbox
4386         */
4387        unselectCheckbox(chkbox?: any): void;
4388        /**
4389         * @param item
4390         * @param silent
4391         */
4392        unselectItem(item?: any, silent?: any): void;
4393        updateButtonsState(): void;
4394        updateListRole(): void;
4395    }
4396}
4397declare namespace PrimeFaces.widget {
4398    /**
4399     * PrimeFaces Poll Widget
4400     */
4401    export class Poll extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
4402        destroy(): void;
4403        /**
4404         * @param cfg
4405         */
4406        init(cfg?: any): void;
4407        /**
4408         * @return
4409         */
4410        isActive(): any;
4411        /**
4412         * @param cfg
4413         */
4414        refresh(cfg?: any): void;
4415        start(): void;
4416        stop(): void;
4417    }
4418}
4419declare namespace PrimeFaces.widget {
4420    /**
4421     * PrimeFaces ProgressBar widget
4422     */
4423    export class ProgressBar extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
4424        cancel(): void;
4425        enableARIA(): void;
4426        fireCompleteEvent(): void;
4427        /**
4428         * @return
4429         */
4430        getValue(): any;
4431        /**
4432         * @param cfg
4433         */
4434        init(cfg?: any): void;
4435        /**
4436         * @param value
4437         */
4438        setValue(value?: any): void;
4439        start(): void;
4440    }
4441}
4442declare namespace PrimeFaces.widget {
4443    /**
4444     * PrimeFaces Rating Widget
4445     */
4446    export class Rating extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
4447        bindEvents(): void;
4448        disable(): void;
4449        enable(): void;
4450        /**
4451         * @return
4452         */
4453        getValue(): any;
4454        /**
4455         * @param cfg
4456         */
4457        init(cfg?: any): void;
4458        reset(): void;
4459        /**
4460         * @param value
4461         */
4462        setValue(value?: any): void;
4463        unbindEvents(): void;
4464    }
4465}
4466declare namespace PrimeFaces.widget {
4467    /**
4468     * PrimeFaces Resizable Widget
4469     */
4470    export class Resizable extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
4471        /**
4472         * @param event
4473         * @param ui
4474         */
4475        fireAjaxResizeEvent(event?: any, ui?: any): void;
4476        /**
4477         * @param cfg
4478         */
4479        init(cfg?: any): void;
4480        /**
4481         * @return
4482         */
4483        render(): any;
4484        renderDeferred(): void;
4485    }
4486}
4487declare namespace PrimeFaces.widget {
4488    /**
4489     * PrimeFaces Ribbon Widget
4490     */
4491    export class Ribbon extends PrimeFaces.widget.TabView {
4492    }
4493}
4494declare namespace PrimeFaces.widget {
4495    /**
4496     * PrimeFaces Ring Widget
4497     */
4498    export class Ring extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
4499        /**
4500         * @param cfg
4501         */
4502        init(cfg?: any): void;
4503    }
4504}
4505declare namespace PrimeFaces.widget {
4506    /**
4507     * PrimeFaces Schedule Widget
4508     */
4509    export class Schedule extends PrimeFaces.widget.DeferredWidget<PrimeFaces.widget.DeferredWidgetCfg> {
4510        bindViewChangeListener(): void;
4511        configureLocale(): void;
4512        /**
4513         * @param cfg
4514         */
4515        init(cfg?: any): void;
4516        setViewOptions(): void;
4517        setupEventHandlers(): void;
4518        setupEventSource(): void;
4519        update(): void;
4520    }
4521}
4522declare namespace PrimeFaces.widget {
4523    /**
4524     * PrimeFaces ScrollPanel Widget
4525     */
4526    export class ScrollPanel extends PrimeFaces.widget.DeferredWidget<PrimeFaces.widget.DeferredWidgetCfg> {
4527        /**
4528         * @param cfg
4529         */
4530        init(cfg?: any): void;
4531        redraw(): void;
4532        /**
4533         * @param x
4534         * @param y
4535         */
4536        scrollTo(x?: any, y?: any): void;
4537        /**
4538         * @param x
4539         */
4540        scrollX(x?: any): void;
4541        /**
4542         * @param y
4543         */
4544        scrollY(y?: any): void;
4545    }
4546}
4547declare namespace PrimeFaces.widget {
4548    /**
4549     * PrimeFaces Sidebar Widget
4550     */
4551    export class Sidebar extends PrimeFaces.widget.DynamicOverlayWidget {
4552        applyARIA(): void;
4553        bindEvents(): void;
4554        enableModality(): void;
4555        /**
4556         * @return
4557         */
4558        getModalTabbables(): any;
4559        hide(): void;
4560        /**
4561         * @param cfg
4562         */
4563        init(cfg?: any): void;
4564        /**
4565         * @return
4566         */
4567        isVisible(): any;
4568        /**
4569         * @param event
4570         * @param ui
4571         */
4572        onHide(event?: any, ui?: any): void;
4573        postShow(): void;
4574        show(): void;
4575        toggle(): void;
4576    }
4577}
4578declare namespace PrimeFaces.widget {
4579    /**
4580     * PrimeFaces Signature Widget
4581     */
4582    export class Signature extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
4583        clear(): void;
4584        /**
4585         * @param value
4586         */
4587        draw(value?: any): void;
4588        handleChange(): void;
4589        /**
4590         * @param cfg
4591         */
4592        init(cfg?: any): void;
4593        render(): void;
4594    }
4595}
4596declare namespace PrimeFaces.widget {
4597    /**
4598     * PrimeFaces Slider Widget
4599     */
4600    export class Slider extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
4601        bindEvents(): void;
4602        bindTouchEvents(): void;
4603        disable(): void;
4604        enable(): void;
4605        /**
4606         * @return
4607         */
4608        getValue(): any;
4609        /**
4610         * @return
4611         */
4612        getValues(): any;
4613        /**
4614         * @param cfg
4615         */
4616        init(cfg?: any): void;
4617        /**
4618         * @param event
4619         * @param ui
4620         */
4621        onSlide(event?: any, ui?: any): void;
4622        /**
4623         * @param event
4624         * @param ui
4625         */
4626        onSlideEnd(event?: any, ui?: any): void;
4627        /**
4628         * @param input
4629         * @param inputValue
4630         */
4631        setInputValue(input?: any, inputValue?: any): void;
4632        /**
4633         * @param value
4634         */
4635        setValue(value?: any): void;
4636        /**
4637         * @param values
4638         */
4639        setValues(values?: any): void;
4640        /**
4641         * @param input
4642         */
4643        triggerOnchange(input?: any): void;
4644    }
4645}
4646declare namespace PrimeFaces.widget {
4647    /**
4648     * PrimeFaces Spinner Widget
4649     */
4650    export class Spinner extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
4651        addARIA(): void;
4652        bindEvents(): void;
4653        format(): void;
4654        /**
4655         * @return
4656         */
4657        getValue(): any;
4658        /**
4659         * @param cfg
4660         */
4661        init(cfg?: any): void;
4662        /**
4663         * @param value
4664         * @return
4665         */
4666        parseValue(value?: any): any;
4667        /**
4668         * @param interval
4669         * @param dir
4670         */
4671        repeat(interval?: any, dir?: any): void;
4672        /**
4673         * @param value
4674         */
4675        setValue(value?: any): void;
4676        /**
4677         * @param dir
4678         */
4679        spin(dir?: any): void;
4680        updateValue(): void;
4681    }
4682}
4683declare namespace PrimeFaces.widget {
4684    /**
4685     * PrimeFaces Spotlight Widget
4686     */
4687    export class Spotlight extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
4688        bindEvents(): void;
4689        calculatePositions(): void;
4690        createMasks(): void;
4691        hide(): void;
4692        /**
4693         * @param cfg
4694         */
4695        init(cfg?: any): void;
4696        show(): void;
4697        unbindEvents(): void;
4698    }
4699}
4700declare namespace PrimeFaces.widget {
4701    /**
4702     * PrimeFaes Stack Widget
4703     */
4704    export class Stack extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
4705        /**
4706         * @param item
4707         */
4708        collapse(item?: any): void;
4709        /**
4710         * @param cfg
4711         */
4712        init(cfg?: any): void;
4713        /**
4714         * @param item
4715         */
4716        open(item?: any): void;
4717    }
4718}
4719declare namespace PrimeFaces.widget {
4720    /**
4721     * PrimeFaces Sticky Widget
4722     */
4723    export class Sticky extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
4724        bindEvents(): void;
4725        /**
4726         * @param force
4727         */
4728        fix(force?: any): void;
4729        /**
4730         * @param cfg
4731         */
4732        init(cfg?: any): void;
4733        /**
4734         * @param cfg
4735         */
4736        refresh(cfg?: any): void;
4737        restore(): void;
4738    }
4739}
4740declare namespace PrimeFaces.widget {
4741    /**
4742     * PrimeFaces TabView Widget
4743     */
4744    export class TabView extends PrimeFaces.widget.DeferredWidget<PrimeFaces.widget.DeferredWidgetCfg> {
4745        bindEvents(): void;
4746        bindKeyEvents(): void;
4747        /**
4748         * @param index
4749         */
4750        disable(index?: any): void;
4751        /**
4752         * @param btn
4753         */
4754        disableScrollerButton(btn?: any): void;
4755        /**
4756         * @param index
4757         */
4758        enable(index?: any): void;
4759        /**
4760         * @param btn
4761         */
4762        enableScrollerButton(btn?: any): void;
4763        /**
4764         * @param panel
4765         */
4766        fireTabChangeEvent(panel?: any): void;
4767        /**
4768         * @param id
4769         * @param index
4770         */
4771        fireTabCloseEvent(id?: any, index?: any): void;
4772        /**
4773         * @return
4774         */
4775        getActiveIndex(): any;
4776        /**
4777         * @return
4778         */
4779        getLength(): any;
4780        /**
4781         * @param cfg
4782         */
4783        init(cfg?: any): void;
4784        initScrolling(): void;
4785        /**
4786         * @param panel
4787         * @return
4788         */
4789        isLoaded(panel?: any): any;
4790        /**
4791         * Loads tab contents with ajax
4792         *
4793         * @param newPanel
4794         */
4795        loadDynamicTab(newPanel?: any): void;
4796        /**
4797         * @param panel
4798         */
4799        markAsLoaded(panel?: any): void;
4800        /**
4801         * @param newPanel
4802         */
4803        postTabShow(newPanel?: any): void;
4804        /**
4805         * Removes a tab with given index
4806         *
4807         * @param index
4808         */
4809        remove(index?: any): void;
4810        renderDeferred(): void;
4811        restoreScrollState(): void;
4812        /**
4813         * @param value
4814         */
4815        saveScrollState(value?: any): void;
4816        /**
4817         * @param step
4818         */
4819        scroll(step?: any): void;
4820        /**
4821         * Selects an inactive tab given index
4822         *
4823         * @param index
4824         * @param silent
4825         * @return
4826         */
4827        select(index?: any, silent?: any): any;
4828        /**
4829         * @param newPanel
4830         */
4831        show(newPanel?: any): void;
4832    }
4833}
4834declare namespace PrimeFaces.widget {
4835    /**
4836     * PrimeFaces TagCloud Widget
4837     */
4838    export class TagCloud extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
4839        /**
4840         * @param link
4841         */
4842        fireSelectEvent(link?: any): void;
4843        /**
4844         * @param cfg
4845         */
4846        init(cfg?: any): void;
4847    }
4848}
4849declare namespace PrimeFaces.widget {
4850    /**
4851     * PrimeFaces Terminal Widget
4852     */
4853    export class Terminal extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
4854        autoCompleteCommand(): void;
4855        bindEvents(): void;
4856        clear(): void;
4857        focus(): void;
4858        /**
4859         * @param cfg
4860         */
4861        init(cfg?: any): void;
4862        processCommand(): void;
4863        /**
4864         * Internally used to add the content from the ajax response to the terminal.
4865         * Can also be used e.g. by a websocket.
4866         *
4867         * @param content
4868         */
4869        processResponse(content?: any): void;
4870    }
4871}
4872declare namespace PrimeFaces.widget {
4873    /**
4874     * PrimeFaces TextEditor Widget
4875     */
4876    export class TextEditor extends PrimeFaces.widget.DeferredWidget<PrimeFaces.widget.DeferredWidgetCfg> {
4877        toolbarTemplate: any;
4878        clear(): void;
4879        /**
4880         * @return
4881         */
4882        getEditorValue(): any;
4883        /**
4884         * @param cfg
4885         */
4886        init(cfg?: any): void;
4887        /**
4888         * @param event
4889         */
4890        registerEvent(event?: any): void;
4891    }
4892}
4893declare namespace PrimeFaces.widget {
4894    export class Timeline extends PrimeFaces.widget.DeferredWidget<PrimeFaces.widget.DeferredWidgetCfg> {
4895        /**
4896         * Adds an event to the timeline. The provided parameter properties is an object, containing parameters
4897         * "start" (Date), "end" (Date), "content" (String), "group" (String). Parameters "end" and "group" are optional.
4898         *
4899         * @param properties event's properties
4900         * @param preventRender flag indicating whether to preventRendering or not (optional)
4901         */
4902        addEvent(properties: any, preventRender: any): void;
4903        /**
4904         * Binds timeline's events.
4905         *
4906         * @param el
4907         */
4908        bindEvents(el?: any): void;
4909        /**
4910         * Cancels event adding.
4911         */
4912        cancelAdd(): void;
4913        /**
4914         * Cancels event changing.
4915         */
4916        cancelChange(): void;
4917        /**
4918         * Cancels event deleting.
4919         */
4920        cancelDelete(): void;
4921        /**
4922         * Changes properties of an existing item in the timeline. The provided parameter properties is an object,
4923         * and can contain parameters "start" (Date), "end" (Date), "content" (String), "group" (String).
4924         *
4925         * @param index index of the event.
4926         * @param properties event's properties
4927         * @param preventRender flag indicating whether to preventRendering or not (optional)
4928         */
4929        changeEvent(index: any, properties: any, preventRender: any): void;
4930        /**
4931         * Check if the timeline container is resized, and if so, resize the timeline. Useful when the webpage is resized.
4932         */
4933        checkResize(): void;
4934        /**
4935         * Deletes all events from the timeline.
4936         */
4937        deleteAllEvents(): void;
4938        /**
4939         * Deletes an existing event.
4940         *
4941         * @param index index of the event.
4942         * @param preventRender flag indicating whether to preventRendering or not (optional)
4943         * (for multiple deletions). Default is false.
4944         */
4945        deleteEvent(index: any, preventRender: any): void;
4946        /**
4947         * Fires event for lazy loading.
4948         */
4949        fireLazyLoading(): void;
4950        /**
4951         * Retrieves the array of current data (events) as an JSON string. This method is useful when you done some changes
4952         * in timeline and want to send them to server to update the backing model (with pe:remoteCommand and pe:convertTimelineEvents).
4953         *
4954         * @return  
4955         */
4956        getData(): Object;
4957        /**
4958         * Retrieves the properties of a single event. The returned object can contain parameters
4959         * "start" (Date), "end" (Date), "content" (String), "group" (String).
4960         *
4961         * @param index
4962         * @return  
4963         */
4964        getEvent(index?: any): Object;
4965        /**
4966         * Gets instance of the Timeline object.
4967         *
4968         * @return  
4969         */
4970        getInstance(): Object;
4971        /**
4972         * Gets time range(s) for events to be lazy loaded.
4973         * The internal time range for already loaded events will be updated.
4974         *
4975         * @return  
4976         */
4977        getLazyLoadRange(): Object;
4978        /**
4979         * Gets number of events (items in the timeline).
4980         *
4981         * @return  
4982         */
4983        getNumberOfEvents(): number;
4984        /**
4985         * Gets currently selected event with properties or null. Properties are
4986         * "start" (Date), "end" (Date), "content" (String), "group" (String), "editable" (boolean).
4987         *
4988         * @return JSON object
4989         */
4990        getSelectedEvent(): Object;
4991        /**
4992         * Gets index of the currently selected event or -1.
4993         *
4994         * @return  
4995         */
4996        getSelectedIndex(): Number;
4997        /**
4998         * Returns an object with start and end properties, which each one of them is a Date object,
4999         * representing the currently visible time range.
5000         *
5001         * @return  
5002         */
5003        getVisibleRange(): Object;
5004        /**
5005         * Initializes the widget.
5006         *
5007         * @param cfg widget configuration's object.
5008         */
5009        init(cfg: Object): void;
5010        /**
5011         * Is the event by given index editable?
5012         *
5013         * @param index index of the event
5014         * @return true - editable, false - not
5015         */
5016        isEditable(index: any): boolean;
5017        /**
5018         * Moves the timeline the given movefactor to the left or right. Start and end date will be adjusted,
5019         * and the timeline will be redrawn. For example, try moveFactor = 0.1 or -0.1. moveFactor is a Number
5020         * that determines the moving amount. A positive value will move right, a negative value will move left.
5021         *
5022         * @param moveFactor Number
5023         * @return
5024         */
5025        move(moveFactor: any): any;
5026        /**
5027         * Force render the timeline component.
5028         *
5029         * @param animate flag to animate the render action (optional)
5030         */
5031        renderTimeline(animate: any): void;
5032        /**
5033         * Selects an event by index. The visible range will be moved,
5034         * so that the selected event is placed in the middle.
5035         * To unselect all events, use a negative index, e.g. index = -1.
5036         *
5037         * @param index
5038         */
5039        setSelection(index: any): void;
5040        /**
5041         * Sets the visible range (zoom) to the specified range. Accepts two parameters of type Date
5042         * that represent the first and last times of the wanted selected visible range.
5043         * Set start to null to include everything from the earliest date to end;
5044         * set end to null to include everything from start to the last date.
5045         *
5046         * @param start start Date
5047         * @param end end Date
5048         * @return
5049         */
5050        setVisibleRange(start: any, end: any): any;
5051        /**
5052         * Zooms the timeline the given zoomfactor in or out. Start and end date will be adjusted,
5053         * and the timeline will be redrawn. You can optionally give a date around which to zoom.
5054         * For example, try zoomfactor = 0.1 or -0.1. zoomFactor is a Number that determines the zooming amount.
5055         * Positive value will zoom in, negative value will zoom out.
5056         * zoomAroundDate is a Date around which to zoom and it is optional.
5057         *
5058         * @param zoomFactor Number
5059         * @param zoomAroundDate Date
5060         * @return
5061         */
5062        zoom(zoomFactor: any, zoomAroundDate: any): any;
5063    }
5064}
5065declare namespace PrimeFaces.widget {
5066    /**
5067     * PrimeFaces ToggleSwitch Widget
5068     */
5069    export class ToggleSwitch extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
5070        check(): void;
5071        /**
5072         * @param cfg
5073         */
5074        init(cfg?: any): void;
5075        toggle(): void;
5076        uncheck(): void;
5077    }
5078}
5079declare namespace PrimeFaces.widget {
5080    /**
5081     * PrimeFaces Tooltip Widget
5082     */
5083    export class Tooltip extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
5084        align(): void;
5085        /**
5086         * @param position
5087         * @param feedback
5088         */
5089        alignUsing(position?: any, feedback?: any): void;
5090        bindGlobal(): void;
5091        bindTarget(): void;
5092        clearTimeout(): void;
5093        followMouse(): void;
5094        /**
5095         * @return
5096         */
5097        getTarget(): any;
5098        hide(): void;
5099        /**
5100         * @param cfg
5101         */
5102        init(cfg?: any): void;
5103        /**
5104         * @return
5105         */
5106        isVisible(): any;
5107        /**
5108         * @param cfg
5109         */
5110        refresh(cfg?: any): void;
5111        show(): void;
5112        unfollowMouse(): void;
5113    }
5114}
5115declare namespace PrimeFaces.widget {
5116    /**
5117     * PrimeFaces Base Tree Widget
5118     */
5119    export class BaseTree extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
5120        /**
5121         * @param rowKey
5122         */
5123        addToSelection(rowKey?: any): void;
5124        /**
5125         * @param menuWidget
5126         * @param targetWidget
5127         * @param targetId
5128         * @param cfg
5129         */
5130        bindContextMenu(menuWidget?: any, targetWidget?: any, targetId?: any, cfg?: any): void;
5131        bindEvents(): void;
5132        /**
5133         * @param checkbox
5134         */
5135        check(checkbox?: any): void;
5136        /**
5137         * @param node
5138         */
5139        expandNode(node?: any): void;
5140        /**
5141         * @param node
5142         */
5143        fireCollapseEvent(node?: any): void;
5144        /**
5145         * @param node
5146         */
5147        fireContextMenuEvent(node?: any): void;
5148        /**
5149         * @param node
5150         */
5151        fireExpandEvent(node?: any): void;
5152        /**
5153         * @param node
5154         */
5155        fireNodeSelectEvent(node?: any): void;
5156        /**
5157         * @param node
5158         */
5159        fireNodeUnselectEvent(node?: any): void;
5160        focusNode(): void;
5161        /**
5162         * @param node
5163         */
5164        getNodeChildrenContainer(node?: any): void;
5165        /**
5166         * @param node
5167         * @return
5168         */
5169        getRowKey(node?: any): any;
5170        /**
5171         * @param cfg
5172         */
5173        init(cfg?: any): void;
5174        initSelection(): void;
5175        /**
5176         * @return
5177         */
5178        isCheckboxSelection(): any;
5179        isEmpty(): void;
5180        /**
5181         * @param node
5182         * @return
5183         */
5184        isExpanded(node?: any): any;
5185        /**
5186         * @return
5187         */
5188        isMultipleSelection(): any;
5189        /**
5190         * @param node
5191         * @return
5192         */
5193        isNodeSelected(node?: any): any;
5194        /**
5195         * @return
5196         */
5197        isSingleSelection(): any;
5198        /**
5199         * @param event
5200         * @param nodeContent
5201         */
5202        nodeClick(event?: any, nodeContent?: any): void;
5203        /**
5204         * @param event
5205         * @param nodeContent
5206         */
5207        nodeRightClick(event?: any, nodeContent?: any): void;
5208        /**
5209         * @param checkbox
5210         */
5211        partialCheck(checkbox?: any): void;
5212        preselectCheckbox(): void;
5213        /**
5214         * @param rowKey
5215         */
5216        removeDescendantsFromSelection(rowKey?: any): void;
5217        /**
5218         * @param rowKey
5219         */
5220        removeFromSelection(rowKey?: any): void;
5221        /**
5222         * @param node
5223         * @param silent
5224         */
5225        selectNode(node?: any, silent?: any): void;
5226        /**
5227         * @param node
5228         */
5229        showNodeChildren(node?: any): void;
5230        /**
5231         * @param node
5232         */
5233        toggleCheckboxNode(node?: any): void;
5234        /**
5235         * @param checkbox
5236         * @param checked
5237         */
5238        toggleCheckboxState(checkbox?: any, checked?: any): void;
5239        /**
5240         * @param checkbox
5241         */
5242        uncheck(checkbox?: any): void;
5243        unselectAllNodes(): void;
5244        /**
5245         * @param node
5246         * @param silent
5247         */
5248        unselectNode(node?: any, silent?: any): void;
5249        writeSelections(): void;
5250    }
5251}
5252declare namespace PrimeFaces.widget {
5253    /**
5254     * PrimeFaces Horizontal Tree Widget
5255     */
5256    export class HorizontalTree extends PrimeFaces.widget.BaseTree {
5257        bindEvents(): void;
5258        /**
5259         * @param checkbox
5260         */
5261        check(checkbox?: any): void;
5262        /**
5263         * @param node
5264         */
5265        collapseNode(node?: any): void;
5266        drawConnectors(): void;
5267        /**
5268         * @param node
5269         */
5270        focusNode(node?: any): void;
5271        /**
5272         * @param node
5273         * @return
5274         */
5275        getNodeChildrenContainer(node?: any): any;
5276        /**
5277         * @param cfg
5278         */
5279        init(cfg?: any): void;
5280        /**
5281         * @return
5282         */
5283        isEmpty(): any;
5284        /**
5285         * @param checkbox
5286         */
5287        partialCheck(checkbox?: any): void;
5288        preselectCheckbox(): void;
5289        /**
5290         * @param node
5291         * @param silent
5292         */
5293        selectNode(node?: any, silent?: any): void;
5294        /**
5295         * @param node
5296         */
5297        showNodeChildren(node?: any): void;
5298        /**
5299         * @param node
5300         */
5301        toggleCheckboxNode(node?: any): void;
5302        /**
5303         * @param checkbox
5304         */
5305        uncheck(checkbox?: any): void;
5306        unselectAllNodes(): void;
5307        /**
5308         * @param node
5309         * @param silent
5310         */
5311        unselectNode(node?: any, silent?: any): void;
5312    }
5313}
5314declare namespace PrimeFaces.widget {
5315    /**
5316     * PrimeFaces Vertical Tree Widget
5317     */
5318    export class VerticalTree extends PrimeFaces.widget.BaseTree {
5319        bindEvents(): void;
5320        bindKeyEvents(): void;
5321        /**
5322         * @param checkbox
5323         */
5324        check(checkbox?: any): void;
5325        clearScrollState(): void;
5326        /**
5327         * @param node
5328         */
5329        collapseNode(node?: any): void;
5330        /**
5331         * Ajax filter
5332         */
5333        filter(): void;
5334        /**
5335         * @param rowkeys
5336         * @return
5337         */
5338        findNodes(rowkeys?: any): any;
5339        /**
5340         * @param arr
5341         * @return
5342         */
5343        findSelectedParentKeys(arr?: any): any;
5344        /**
5345         * @param dragNode
5346         * @param dragMode
5347         * @return
5348         */
5349        findTargetDragNode(dragNode?: any, dragMode?: any): any;
5350        /**
5351         * @param event
5352         */
5353        fireDragDropEvent(event?: any): void;
5354        /**
5355         * @param node
5356         */
5357        focusNode(node?: any): void;
5358        /**
5359         * @return
5360         */
5361        getFirstNode(): any;
5362        /**
5363         * @param node
5364         * @return
5365         */
5366        getNodeChildrenContainer(node?: any): any;
5367        /**
5368         * @param node
5369         * @return
5370         */
5371        getNodeLabel(node?: any): any;
5372        /**
5373         * @param cfg
5374         */
5375        init(cfg?: any): void;
5376        initDraggable(): void;
5377        initDropScrollers(): void;
5378        initDroppable(): void;
5379        /**
5380         * @return
5381         */
5382        isEmpty(): any;
5383        /**
5384         * @param elements
5385         */
5386        makeDraggable(elements?: any): void;
5387        /**
5388         * @param elements
5389         */
5390        makeDropNodes(elements?: any): void;
5391        /**
5392         * @param elements
5393         */
5394        makeDropPoints(elements?: any): void;
5395        /**
5396         * @param node
5397         */
5398        makeLeaf(node?: any): void;
5399        /**
5400         * @param node
5401         */
5402        makeParent(node?: any): void;
5403        /**
5404         * @param ui
5405         * @param dragSource
5406         * @param dragNode
5407         * @param targetDragNode
5408         * @param droppable
5409         * @param dropNode
5410         * @param transfer
5411         */
5412        onDropNode(ui?: any, dragSource?: any, dragNode?: any, targetDragNode?: any, droppable?: any, dropNode?: any, transfer?: any): void;
5413        /**
5414         * @param ui
5415         * @param dragSource
5416         * @param dragNode
5417         * @param targetDragNode
5418         * @param dropPoint
5419         * @param dropNode
5420         * @param transfer
5421         */
5422        onDropPoint(ui?: any, dragSource?: any, dragNode?: any, targetDragNode?: any, dropPoint?: any, dropNode?: any, transfer?: any): void;
5423        /**
5424         * @param node
5425         * @param childrenContainer
5426         */
5427        postCollapse(node?: any, childrenContainer?: any): void;
5428        preselectCheckbox(): void;
5429        /**
5430         * @param node
5431         */
5432        propagateDNDCheckbox(node?: any): void;
5433        restoreScrollState(): void;
5434        saveScrollState(): void;
5435        /**
5436         * @param step
5437         */
5438        scroll(step?: any): void;
5439        /**
5440         * @param node
5441         * @return
5442         */
5443        searchDown(node?: any): any;
5444        /**
5445         * @param node
5446         * @param silent
5447         */
5448        selectNode(node?: any, silent?: any): void;
5449        /**
5450         * @param node
5451         */
5452        showNodeChildren(node?: any): void;
5453        /**
5454         * @param dragSource
5455         * @param oldParentNode
5456         * @param newParentNode
5457         */
5458        syncDNDCheckboxes(dragSource?: any, oldParentNode?: any, newParentNode?: any): void;
5459        syncDragDrop(): void;
5460        /**
5461         * @param node
5462         */
5463        toggleCheckboxNode(node?: any): void;
5464        /**
5465         * @param checkbox
5466         */
5467        uncheck(checkbox?: any): void;
5468        unselectAllNodes(): void;
5469        /**
5470         * @param node
5471         * @param silent
5472         */
5473        unselectNode(node?: any, silent?: any): void;
5474        /**
5475         * @param node
5476         */
5477        unselectSubtree(node?: any): void;
5478        /**
5479         * @param children
5480         * @param rowkey
5481         */
5482        updateChildrenRowKeys(children?: any, rowkey?: any): void;
5483        /**
5484         * @param node
5485         */
5486        updateDragDropBindings(node?: any): void;
5487        updateRowKeys(): void;
5488        /**
5489         * @param dragNode
5490         * @param dropNode
5491         * @param oldParentNode
5492         * @return
5493         */
5494        validateDropNode(dragNode?: any, dropNode?: any, oldParentNode?: any): any;
5495        /**
5496         * @param dragNode
5497         * @param dropPoint
5498         * @return
5499         */
5500        validateDropPoint(dragNode?: any, dropPoint?: any): any;
5501    }
5502}
5503declare namespace PrimeFaces.widget {
5504    /**
5505     * PrimeFaces TreeTable Widget
5506     */
5507    export class TreeTable extends PrimeFaces.widget.DeferredWidget<PrimeFaces.widget.DeferredWidgetCfg> {
5508        /**
5509         * @param rowKey
5510         */
5511        addToSelection(rowKey?: any): void;
5512        adjustScrollHeight(): void;
5513        adjustScrollWidth(): void;
5514        alignScrollBody(): void;
5515        applyViewPortScrollHeight(): void;
5516        /**
5517         * @param filter
5518         */
5519        bindChangeFilter(filter?: any): void;
5520        /**
5521         * @param menuWidget
5522         * @param targetWidget
5523         * @param targetId
5524         * @param cfg
5525         */
5526        bindContextMenu(menuWidget?: any, targetWidget?: any, targetId?: any, cfg?: any): void;
5527        bindEditEvents(): void;
5528        /**
5529         * @param filter
5530         */
5531        bindEnterKeyFilter(filter?: any): void;
5532        bindEvents(): void;
5533        /**
5534         * @param filter
5535         */
5536        bindFilterEvent(filter?: any): void;
5537        bindSelectionEvents(): void;
5538        bindSortEvents(): void;
5539        /**
5540         * @param filter
5541         */
5542        bindTextFilter(filter?: any): void;
5543        /**
5544         * Cancels row editing
5545         *
5546         * @param rowEditor
5547         */
5548        cancelRowEdit(rowEditor?: any): void;
5549        /**
5550         * @param cell
5551         */
5552        cellEditInit(cell?: any): void;
5553        /**
5554         * Clears table filters
5555         */
5556        clearFilters(): void;
5557        cloneHead(): void;
5558        /**
5559         * @param node
5560         */
5561        collapseNode(node?: any): void;
5562        /**
5563         * @param row
5564         */
5565        collapseRow(row?: any): void;
5566        /**
5567         * @param cell
5568         */
5569        doCellEditCancelRequest(cell?: any): void;
5570        /**
5571         * @param cell
5572         */
5573        doCellEditRequest(cell?: any): void;
5574        /**
5575         * Sends an ajax request to handle row save or cancel
5576         *
5577         * @param rowEditor
5578         * @param action
5579         */
5580        doRowEditRequest(rowEditor?: any, action?: any): void;
5581        /**
5582         * @param node
5583         */
5584        expandNode(node?: any): void;
5585        /**
5586         * Ajax filter
5587         */
5588        filter(): void;
5589        /**
5590         * @param nodeKey
5591         */
5592        fireSelectNodeEvent(nodeKey?: any): void;
5593        /**
5594         * @param nodeKey
5595         */
5596        fireUnselectNodeEvent(nodeKey?: any): void;
5597        fixColumnWidths(): void;
5598        /**
5599         * @param node
5600         * @return
5601         */
5602        getChildren(node?: any): any;
5603        /**
5604         * @param node
5605         * @return
5606         */
5607        getDescendants(node?: any): any;
5608        /**
5609         * @return
5610         */
5611        getPaginator(): any;
5612        /**
5613         * @param node
5614         * @return
5615         */
5616        getParent(node?: any): any;
5617        /**
5618         * Finds all editors of a row
5619         *
5620         * @param row
5621         * @return
5622         */
5623        getRowEditors(row?: any): any;
5624        /**
5625         * @return
5626         */
5627        getScrollbarWidth(): any;
5628        /**
5629         * @param newState
5630         */
5631        handlePagination(newState?: any): void;
5632        /**
5633         * @return
5634         */
5635        hasVerticalOverflow(): any;
5636        /**
5637         * @param nodes
5638         */
5639        indeterminateNodes(nodes?: any): void;
5640        /**
5641         * @param cfg
5642         */
5643        init(cfg?: any): void;
5644        /**
5645         * Displays row editors in invalid format
5646         *
5647         * @param index
5648         */
5649        invalidateRow(index?: any): void;
5650        /**
5651         * @return
5652         */
5653        isCheckboxSelection(): any;
5654        /**
5655         * @return
5656         */
5657        isMultipleSelection(): any;
5658        /**
5659         * @param nodeKey
5660         * @return
5661         */
5662        isSelected(nodeKey?: any): any;
5663        /**
5664         * @return
5665         */
5666        isSingleSelection(): any;
5667        /**
5668         * @param event
5669         * @param node
5670         */
5671        onRowClick(event?: any, node?: any): void;
5672        /**
5673         * @param event
5674         * @param node
5675         */
5676        onRowRightClick(event?: any, node?: any): void;
5677        /**
5678         * @param node
5679         */
5680        propagateUp(node?: any): void;
5681        reclone(): void;
5682        /**
5683         * @param cfg
5684         */
5685        refresh(cfg?: any): void;
5686        /**
5687         * @param rowKey
5688         */
5689        removeDescendantsFromSelection(rowKey?: any): void;
5690        /**
5691         * @param nodeKey
5692         */
5693        removeSelection(nodeKey?: any): void;
5694        /**
5695         * @param event
5696         * @param ui
5697         */
5698        resize(event?: any, ui?: any): void;
5699        restoreScrollState(): void;
5700        /**
5701         * @param cell
5702         */
5703        saveCell(cell?: any): void;
5704        /**
5705         * Saves the edited row
5706         *
5707         * @param rowEditor
5708         */
5709        saveRowEdit(rowEditor?: any): void;
5710        saveScrollState(): void;
5711        /**
5712         * @param node
5713         * @param silent
5714         */
5715        selectNode(node?: any, silent?: any): void;
5716        /**
5717         * @param node
5718         */
5719        selectNodesInRange(node?: any): void;
5720        /**
5721         * @param element
5722         * @param width
5723         */
5724        setOuterWidth(element?: any, width?: any): void;
5725        /**
5726         * @param width
5727         */
5728        setScrollWidth(width?: any): void;
5729        /**
5730         * Binds filter events to standard filters
5731         */
5732        setupFiltering(): void;
5733        setupResizableColumns(): void;
5734        setupScrolling(): void;
5735        setupStickyHeader(): void;
5736        /**
5737         * @param c
5738         */
5739        showCellEditor(c?: any): void;
5740        /**
5741         * @param cell
5742         */
5743        showCurrentCell(cell?: any): void;
5744        /**
5745         * @param row
5746         */
5747        showRowEditors(row?: any): void;
5748        /**
5749         * @param columnHeader
5750         * @param order
5751         */
5752        sort(columnHeader?: any, order?: any): void;
5753        /**
5754         * @param row
5755         */
5756        switchToRowEdit(row?: any): void;
5757        /**
5758         * @param cell
5759         * @param forward
5760         */
5761        tabCell(cell?: any, forward?: any): void;
5762        /**
5763         * @param node
5764         */
5765        toggleCheckboxNode(node?: any): void;
5766        unselectAllNodes(): void;
5767        /**
5768         * @param node
5769         * @param silent
5770         */
5771        unselectNode(node?: any, silent?: any): void;
5772        updateColumnWidths(): void;
5773        /**
5774         * Updates rows with given content
5775         *
5776         * @param row
5777         * @param content
5778         */
5779        updateRows(row?: any, content?: any): void;
5780        updateVerticalScroll(): void;
5781        /**
5782         * @param cell
5783         */
5784        viewMode(cell?: any): void;
5785        writeSelections(): void;
5786    }
5787}
5788declare namespace PrimeFaces.widget {
5789    export class TriStateCheckbox extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
5790        /**
5791         * @param cfg
5792         */
5793        init(cfg?: any): void;
5794        /**
5795         * @param direction
5796         */
5797        toggle(direction?: any): void;
5798    }
5799}
5800declare namespace PrimeFaces.widget {
5801    /**
5802     * PrimeFaces Watermark Widget
5803     */
5804    export class Watermark extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
5805        /**
5806         * @param cfg
5807         */
5808        init(cfg?: any): void;
5809    }
5810}
5811declare namespace PrimeFaces.widget {
5812    /**
5813     * PrimeFaces Wizard Component
5814     */
5815    export class Wizard extends PrimeFaces.widget.BaseWidget<PrimeFaces.widget.BaseWidgetCfg> {
5816        back(): void;
5817        /**
5818         * @param step
5819         * @return
5820         */
5821        getStepIndex(step?: any): any;
5822        hideBackNav(): void;
5823        hideNextNav(): void;
5824        /**
5825         * @param cfg
5826         */
5827        init(cfg?: any): void;
5828        /**
5829         * @param stepToGo
5830         * @param event
5831         */
5832        loadStep(stepToGo?: any, event?: any): void;
5833        next(): void;
5834        showBackNav(): void;
5835        showNextNav(): void;
5836    }
5837}