@gipisistemas/ng-core 1.0.67 → 1.0.68

package/shared/gipi-components/datepicker/mat-datepicker/multi-year-view.d.ts

@@ -0,0 +1,85 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Directionality } from '@angular/cdk/bidi';
+import { AfterContentInit, ChangeDetectorRef, EventEmitter, OnDestroy } from '@angular/core';
+import { MatCalendarBody, MatCalendarCell, MatCalendarCellClassFunction, MatCalendarUserEvent } from './calendar-body';
+import { DateRange } from './date-selection-model';
+import { DateAdapter } from './shared/adapter/date-adapter';
+export declare const yearsPerPage = 24;
+export declare const yearsPerRow = 4;
+/**
+ * An internal component used to display a year selector in the datepicker.
+ * @docs-private
+ */
+export declare class MatMultiYearView<D> implements AfterContentInit, OnDestroy {
+    private _changeDetectorRef;
+    _dateAdapter: DateAdapter<D>;
+    private _dir?;
+    private _rerenderSubscription;
+    /** The date to display in this multi-year view (everything other than the year is ignored). */
+    get activeDate(): D;
+    set activeDate(value: D);
+    private _activeDate;
+    /** The currently selected date. */
+    get selected(): DateRange<D> | D | null;
+    set selected(value: DateRange<D> | D | null);
+    private _selected;
+    /** The minimum selectable date. */
+    get minDate(): D | null;
+    set minDate(value: D | null);
+    private _minDate;
+    /** The maximum selectable date. */
+    get maxDate(): D | null;
+    set maxDate(value: D | null);
+    private _maxDate;
+    /** A function used to filter which dates are selectable. */
+    dateFilter: (date: D) => boolean;
+    /** Function that can be used to add custom CSS classes to date cells. */
+    dateClass: MatCalendarCellClassFunction<D>;
+    /** Emits when a new year is selected. */
+    readonly selectedChange: EventEmitter<D>;
+    /** Emits the selected year. This doesn't imply a change on the selected date */
+    readonly yearSelected: EventEmitter<D>;
+    /** Emits when any date is activated. */
+    readonly activeDateChange: EventEmitter<D>;
+    /** The body of calendar table */
+    _matCalendarBody: MatCalendarBody;
+    /** Grid of calendar cells representing the currently displayed years. */
+    _years: MatCalendarCell[][];
+    /** The year that today falls on. */
+    _todayYear: number;
+    /** The year of the selected date. Null if the selected date is null. */
+    _selectedYear: number | null;
+    constructor(_changeDetectorRef: ChangeDetectorRef, _dateAdapter: DateAdapter<D>, _dir?: Directionality);
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    /** Initializes this multi-year view. */
+    _init(): void;
+    /** Handles when a new year is selected. */
+    _yearSelected(event: MatCalendarUserEvent<number>): void;
+    /** Handles keydown events on the calendar body when calendar is in multi-year view. */
+    _handleCalendarBodyKeydown(event: KeyboardEvent): void;
+    _getActiveCell(): number;
+    /** Focuses the active cell after the microtask queue is empty. */
+    _focusActiveCell(): void;
+    /** Creates an MatCalendarCell for the given year. */
+    private _createCellForYear;
+    /** Whether the given year is enabled. */
+    private _shouldEnableYear;
+    /** Determines whether the user has the RTL layout direction. */
+    private _isRtl;
+    /** Sets the currently-highlighted year based on a model value. */
+    private _setSelectedYear;
+}
+export declare function isSameMultiYearView<D>(dateAdapter: DateAdapter<D>, date1: D, date2: D, minDate: D | null, maxDate: D | null): boolean;
+/**
+ * When the multi-year view is first opened, the active year will be in view.
+ * So we compute how many years are between the active year and the *slot* where our
+ * "startingYear" will render when paged into view.
+ */
+export declare function getActiveOffset<D>(dateAdapter: DateAdapter<D>, activeDate: D, minDate: D | null, maxDate: D | null): number;

package/shared/gipi-components/datepicker/mat-datepicker/shared/adapter/date-adapter.d.ts

@@ -0,0 +1,225 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { InjectionToken } from '@angular/core';
+import { Observable, Subject } from 'rxjs';
+/** InjectionToken for datepicker that can be used to override default locale code. */
+export declare const MAT_DATE_LOCALE: InjectionToken<string>;
+/** @docs-private */
+export declare function MAT_DATE_LOCALE_FACTORY(): string;
+/**
+ * No longer needed since MAT_DATE_LOCALE has been changed to a scoped injectable.
+ * If you are importing and providing this in your code you can simply remove it.
+ * @deprecated
+ * @breaking-change 8.0.0
+ */
+export declare const MAT_DATE_LOCALE_PROVIDER: {
+    provide: InjectionToken<string>;
+    useExisting: InjectionToken<string>;
+};
+/** Adapts type `D` to be usable as a date by cdk-based components that work with dates. */
+export declare abstract class DateAdapter<D> {
+    /** The locale to use for all dates. */
+    protected locale: any;
+    protected _localeChanges: Subject<void>;
+    /** A stream that emits when the locale changes. */
+    readonly localeChanges: Observable<void>;
+    /**
+     * Gets the year component of the given date.
+     * @param date The date to extract the year from.
+     * @returns The year component.
+     */
+    abstract getYear(date: D): number;
+    /**
+     * Gets the month component of the given date.
+     * @param date The date to extract the month from.
+     * @returns The month component (0-indexed, 0 = January).
+     */
+    abstract getMonth(date: D): number;
+    /**
+     * Gets the date of the month component of the given date.
+     * @param date The date to extract the date of the month from.
+     * @returns The month component (1-indexed, 1 = first of month).
+     */
+    abstract getDate(date: D): number;
+    /**
+     * Gets the day of the week component of the given date.
+     * @param date The date to extract the day of the week from.
+     * @returns The month component (0-indexed, 0 = Sunday).
+     */
+    abstract getDayOfWeek(date: D): number;
+    /**
+     * Gets a list of names for the months.
+     * @param style The naming style (e.g. long = 'January', short = 'Jan', narrow = 'J').
+     * @returns An ordered list of all month names, starting with January.
+     */
+    abstract getMonthNames(style: 'long' | 'short' | 'narrow'): string[];
+    /**
+     * Gets a list of names for the dates of the month.
+     * @returns An ordered list of all date of the month names, starting with '1'.
+     */
+    abstract getDateNames(): string[];
+    /**
+     * Gets a list of names for the days of the week.
+     * @param style The naming style (e.g. long = 'Sunday', short = 'Sun', narrow = 'S').
+     * @returns An ordered list of all weekday names, starting with Sunday.
+     */
+    abstract getDayOfWeekNames(style: 'long' | 'short' | 'narrow'): string[];
+    /**
+     * Gets the name for the year of the given date.
+     * @param date The date to get the year name for.
+     * @returns The name of the given year (e.g. '2017').
+     */
+    abstract getYearName(date: D): string;
+    /**
+     * Gets the first day of the week.
+     * @returns The first day of the week (0-indexed, 0 = Sunday).
+     */
+    abstract getFirstDayOfWeek(): number;
+    /**
+     * Gets the number of days in the month of the given date.
+     * @param date The date whose month should be checked.
+     * @returns The number of days in the month of the given date.
+     */
+    abstract getNumDaysInMonth(date: D): number;
+    /**
+     * Clones the given date.
+     * @param date The date to clone
+     * @returns A new date equal to the given date.
+     */
+    abstract clone(date: D): D;
+    /**
+     * Creates a date with the given year, month, and date. Does not allow over/under-flow of the
+     * month and date.
+     * @param year The full year of the date. (e.g. 89 means the year 89, not the year 1989).
+     * @param month The month of the date (0-indexed, 0 = January). Must be an integer 0 - 11.
+     * @param date The date of month of the date. Must be an integer 1 - length of the given month.
+     * @returns The new date, or null if invalid.
+     */
+    abstract createDate(year: number, month: number, date: number): D;
+    /**
+     * Gets today's date.
+     * @returns Today's date.
+     */
+    abstract today(): D;
+    /**
+     * Parses a date from a user-provided value.
+     * @param value The value to parse.
+     * @param parseFormat The expected format of the value being parsed
+     *     (type is implementation-dependent).
+     * @returns The parsed date.
+     */
+    abstract parse(value: any, parseFormat: any): D | null;
+    /**
+     * Formats a date as a string according to the given format.
+     * @param date The value to format.
+     * @param displayFormat The format to use to display the date as a string.
+     * @returns The formatted date string.
+     */
+    abstract format(date: D, displayFormat: any): string;
+    /**
+     * Adds the given number of years to the date. Years are counted as if flipping 12 pages on the
+     * calendar for each year and then finding the closest date in the new month. For example when
+     * adding 1 year to Feb 29, 2016, the resulting date will be Feb 28, 2017.
+     * @param date The date to add years to.
+     * @param years The number of years to add (may be negative).
+     * @returns A new date equal to the given one with the specified number of years added.
+     */
+    abstract addCalendarYears(date: D, years: number): D;
+    /**
+     * Adds the given number of months to the date. Months are counted as if flipping a page on the
+     * calendar for each month and then finding the closest date in the new month. For example when
+     * adding 1 month to Jan 31, 2017, the resulting date will be Feb 28, 2017.
+     * @param date The date to add months to.
+     * @param months The number of months to add (may be negative).
+     * @returns A new date equal to the given one with the specified number of months added.
+     */
+    abstract addCalendarMonths(date: D, months: number): D;
+    /**
+     * Adds the given number of days to the date. Days are counted as if moving one cell on the
+     * calendar for each day.
+     * @param date The date to add days to.
+     * @param days The number of days to add (may be negative).
+     * @returns A new date equal to the given one with the specified number of days added.
+     */
+    abstract addCalendarDays(date: D, days: number): D;
+    /**
+     * Gets the RFC 3339 compatible string (https://tools.ietf.org/html/rfc3339) for the given date.
+     * This method is used to generate date strings that are compatible with native HTML attributes
+     * such as the `min` or `max` attribute of an `<input>`.
+     * @param date The date to get the ISO date string for.
+     * @returns The ISO date string date string.
+     */
+    abstract toIso8601(date: D): string;
+    /**
+     * Checks whether the given object is considered a date instance by this DateAdapter.
+     * @param obj The object to check
+     * @returns Whether the object is a date instance.
+     */
+    abstract isDateInstance(obj: any): boolean;
+    /**
+     * Checks whether the given date is valid.
+     * @param date The date to check.
+     * @returns Whether the date is valid.
+     */
+    abstract isValid(date: D): boolean;
+    /**
+     * Gets date instance that is not valid.
+     * @returns An invalid date.
+     */
+    abstract invalid(): D;
+    /**
+     * Given a potential date object, returns that same date object if it is
+     * a valid date, or `null` if it's not a valid date.
+     * @param obj The object to check.
+     * @returns A date or `null`.
+     */
+    getValidDateOrNull(obj: unknown): D | null;
+    /**
+     * Attempts to deserialize a value to a valid date object. This is different from parsing in that
+     * deserialize should only accept non-ambiguous, locale-independent formats (e.g. a ISO 8601
+     * string). The default implementation does not allow any deserialization, it simply checks that
+     * the given value is already a valid date object or null. The `<mat-datepicker>` will call this
+     * method on all of its `@Input()` properties that accept dates. It is therefore possible to
+     * support passing values from your backend directly to these properties by overriding this method
+     * to also deserialize the format used by your backend.
+     * @param value The value to be deserialized into a date object.
+     * @returns The deserialized date object, either a valid date, null if the value can be
+     *     deserialized into a null date (e.g. the empty string), or an invalid date.
+     */
+    deserialize(value: any): D | null;
+    /**
+     * Sets the locale used for all dates.
+     * @param locale The new locale.
+     */
+    setLocale(locale: any): void;
+    /**
+     * Compares two dates.
+     * @param first The first date to compare.
+     * @param second The second date to compare.
+     * @returns 0 if the dates are equal, a number less than 0 if the first date is earlier,
+     *     a number greater than 0 if the first date is later.
+     */
+    compareDate(first: D, second: D): number;
+    /**
+     * Checks if two dates are equal.
+     * @param first The first date to check.
+     * @param second The second date to check.
+     * @returns Whether the two dates are equal.
+     *     Null dates are considered equal to other null dates.
+     */
+    sameDate(first: D | null, second: D | null): boolean;
+    /**
+     * Clamp the given date between min and max dates.
+     * @param date The date to clamp.
+     * @param min The minimum value to allow. If null or omitted no min is enforced.
+     * @param max The maximum value to allow. If null or omitted no max is enforced.
+     * @returns `min` if `date` is less than `min`, `max` if date is greater than `max`,
+     *     otherwise `date`.
+     */
+    clampDate(date: D, min?: D | null, max?: D | null): D;
+}

package/shared/gipi-components/datepicker/mat-datepicker/shared/adapter/date-formats.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { InjectionToken } from '@angular/core';
+export declare type MatDateFormats = {
+    parse: {
+        dateInput: any;
+    };
+    display: {
+        dateInput: any;
+        monthYearLabel: any;
+        dateA11yLabel: any;
+        monthYearA11yLabel: any;
+    };
+};
+export declare const MAT_DATE_FORMATS: InjectionToken<MatDateFormats>;

package/shared/gipi-components/datepicker/mat-datepicker/shared/adapter/native-date-adapter.d.ts

@@ -0,0 +1,76 @@
+import { DateAdapter } from './date-adapter';
+/** Adapts the native JS Date for use with cdk-based components that work with dates. */
+export declare class NativeDateAdapter extends DateAdapter<Date> {
+    private _platformId;
+    /** Whether to clamp the date between 1 and 9999 to avoid IE and Edge errors. */
+    private readonly _clampDate;
+    /**
+     * Whether to use `timeZone: 'utc'` with `Intl.DateTimeFormat` when formatting dates.
+     * Without this `Intl.DateTimeFormat` sometimes chooses the wrong timeZone, which can throw off
+     * the result. (e.g. in the en-US locale `new Date(1800, 7, 14).toLocaleDateString()`
+     * will produce `'8/13/1800'`.
+     *
+     * TODO(mmalerba): drop this variable. It's not being used in the code right now. We're now
+     * getting the string representation of a Date object from its utc representation. We're keeping
+     * it here for sometime, just for precaution, in case we decide to revert some of these changes
+     * though.
+     */
+    useUtcForDisplay: boolean;
+    constructor(matDateLocale: string, _platformId: Object);
+    getYear(date: Date): number;
+    getMonth(date: Date): number;
+    getDate(date: Date): number;
+    getDayOfWeek(date: Date): number;
+    getMonthNames(style: 'long' | 'short' | 'narrow'): string[];
+    getDateNames(): string[];
+    getDayOfWeekNames(style: 'long' | 'short' | 'narrow'): string[];
+    getYearName(date: Date): string;
+    getFirstDayOfWeek(): number;
+    getNumDaysInMonth(date: Date): number;
+    clone(date: Date): Date;
+    createDate(year: number, month: number, date: number): Date;
+    today(): Date;
+    parse(value: any): Date | null;
+    format(date: Date, displayFormat: Object): string;
+    addCalendarYears(date: Date, years: number): Date;
+    addCalendarMonths(date: Date, months: number): Date;
+    addCalendarDays(date: Date, days: number): Date;
+    toIso8601(date: Date): string;
+    /**
+     * Returns the given value if given a valid Date or null. Deserializes valid ISO 8601 strings
+     * (https://www.ietf.org/rfc/rfc3339.txt) into valid Dates and empty string into null. Returns an
+     * invalid date for all other values.
+     */
+    deserialize(value: any): Date | null;
+    isDateInstance(obj: any): boolean;
+    isValid(date: Date): boolean;
+    invalid(): Date;
+    /** Creates a date but allows the month and date to overflow. */
+    private _createDateWithOverflow;
+    /**
+     * Pads a number to make it two digits.
+     * @param n The number to pad.
+     * @returns The padded number.
+     */
+    private _2digit;
+    /**
+     * Strip out unicode LTR and RTL characters. Edge and IE insert these into formatted dates while
+     * other browsers do not. We remove them to make output consistent and because they interfere with
+     * date parsing.
+     * @param str The string to strip direction characters from.
+     * @returns The stripped string.
+     */
+    private _stripDirectionalityCharacters;
+    /**
+     * When converting Date object to string, javascript built-in functions may return wrong
+     * results because it applies its internal DST rules. The DST rules around the world change
+     * very frequently, and the current valid rule is not always valid in previous years though.
+     * We work around this problem building a new Date object which has its internal UTC
+     * representation with the local date and time.
+     * @param dtf Intl.DateTimeFormat object, containg the desired string format. It must have
+     *    timeZone set to 'utc' to work fine.
+     * @param date Date from which we want to get the string representation according to dtf
+     * @returns A Date object with its UTC representation based on the passed in date info
+     */
+    private _format;
+}

package/shared/gipi-components/datepicker/mat-datepicker/shared/adapter/native-date-formats.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { MatDateFormats } from './date-formats';
+export declare const MAT_NATIVE_DATE_FORMATS: MatDateFormats;

package/shared/gipi-components/datepicker/mat-datepicker/shared/adapter/platform.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * Service to detect the current platform by comparing the userAgent strings and
+ * checking browser-specific global properties.
+ */
+export declare class Platform {
+    private _platformId;
+    /** Whether the Angular application is being rendered in the browser. */
+    isBrowser: boolean;
+    /** Whether the current browser is Microsoft Edge. */
+    EDGE: boolean;
+    /** Whether the current rendering engine is Microsoft Trident. */
+    TRIDENT: boolean;
+    /** Whether the current rendering engine is Blink. */
+    BLINK: boolean;
+    /** Whether the current rendering engine is WebKit. */
+    WEBKIT: boolean;
+    /** Whether the current platform is Apple iOS. */
+    IOS: boolean;
+    /** Whether the current browser is Firefox. */
+    FIREFOX: boolean;
+    /** Whether the current platform is Android. */
+    ANDROID: boolean;
+    /** Whether the current browser is Safari. */
+    SAFARI: boolean;
+    constructor(_platformId: Object);
+}

package/shared/gipi-components/datepicker/mat-datepicker/year-view.d.ts

@@ -0,0 +1,97 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Directionality } from '@angular/cdk/bidi';
+import { AfterContentInit, ChangeDetectorRef, EventEmitter, OnDestroy } from '@angular/core';
+import { MatDateFormats } from '@angular/material/core';
+import { MatCalendarBody, MatCalendarCell, MatCalendarCellClassFunction, MatCalendarUserEvent } from './calendar-body';
+import { DateRange } from './date-selection-model';
+import { DateAdapter } from './shared/adapter/date-adapter';
+/**
+ * An internal component used to display a single year in the datepicker.
+ * @docs-private
+ */
+export declare class MatYearView<D> implements AfterContentInit, OnDestroy {
+    private _changeDetectorRef;
+    private _dateFormats;
+    _dateAdapter: DateAdapter<D>;
+    private _dir?;
+    private _rerenderSubscription;
+    /** The date to display in this year view (everything other than the year is ignored). */
+    get activeDate(): D;
+    set activeDate(value: D);
+    private _activeDate;
+    /** The currently selected date. */
+    get selected(): DateRange<D> | D | null;
+    set selected(value: DateRange<D> | D | null);
+    private _selected;
+    /** The minimum selectable date. */
+    get minDate(): D | null;
+    set minDate(value: D | null);
+    private _minDate;
+    /** The maximum selectable date. */
+    get maxDate(): D | null;
+    set maxDate(value: D | null);
+    private _maxDate;
+    /** A function used to filter which dates are selectable. */
+    dateFilter: (date: D) => boolean;
+    /** Function that can be used to add custom CSS classes to date cells. */
+    dateClass: MatCalendarCellClassFunction<D>;
+    /** Emits when a new month is selected. */
+    readonly selectedChange: EventEmitter<D>;
+    /** Emits the selected month. This doesn't imply a change on the selected date */
+    readonly monthSelected: EventEmitter<D>;
+    /** Emits when any date is activated. */
+    readonly activeDateChange: EventEmitter<D>;
+    /** The body of calendar table */
+    _matCalendarBody: MatCalendarBody;
+    /** Grid of calendar cells representing the months of the year. */
+    _months: MatCalendarCell[][];
+    /** The label for this year (e.g. "2017"). */
+    _yearLabel: string;
+    /** The month in this year that today falls on. Null if today is in a different year. */
+    _todayMonth: number | null;
+    /**
+     * The month in this year that the selected Date falls on.
+     * Null if the selected Date is in a different year.
+     */
+    _selectedMonth: number | null;
+    constructor(_changeDetectorRef: ChangeDetectorRef, _dateFormats: MatDateFormats, _dateAdapter: DateAdapter<D>, _dir?: Directionality);
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    /** Handles when a new month is selected. */
+    _monthSelected(event: MatCalendarUserEvent<number>): void;
+    /** Handles keydown events on the calendar body when calendar is in year view. */
+    _handleCalendarBodyKeydown(event: KeyboardEvent): void;
+    /** Initializes this year view. */
+    _init(): void;
+    /** Focuses the active cell after the microtask queue is empty. */
+    _focusActiveCell(): void;
+    /**
+     * Gets the month in this year that the given Date falls on.
+     * Returns null if the given Date is in another year.
+     */
+    private _getMonthInCurrentYear;
+    /** Creates an MatCalendarCell for the given month. */
+    private _createCellForMonth;
+    /** Whether the given month is enabled. */
+    private _shouldEnableMonth;
+    /**
+     * Tests whether the combination month/year is after this.maxDate, considering
+     * just the month and year of this.maxDate
+     */
+    private _isYearAndMonthAfterMaxDate;
+    /**
+     * Tests whether the combination month/year is before this.minDate, considering
+     * just the month and year of this.minDate
+     */
+    private _isYearAndMonthBeforeMinDate;
+    /** Determines whether the user has the RTL layout direction. */
+    private _isRtl;
+    /** Sets the currently-selected month based on a model value. */
+    private _setSelectedMonth;
+}

package/shared/gipi-components/dom/connected-overlay-scroll-handler.d.ts

@@ -0,0 +1,9 @@
+export declare class GIPIConnectedOverlayScrollHandler {
+    element: any;
+    listener: any;
+    scrollableParents: any;
+    constructor(element: any, listener?: any);
+    bindScrollListener(): void;
+    unbindScrollListener(): void;
+    destroy(): void;
+}

package/shared/gipi-components/dom/dom-handler.d.ts

@@ -0,0 +1,85 @@
+/**
+ * @dynamic é para inicializar DomHandler.browser em tempo de execução
+ *
+ * Se excluir o comentário abaixo, podemos ver esta mensagem de erro:
+ * Os metadados coletados contêm um erro que será reportado em tempo de execução:
+ * Somente variáveis ​​e constantes inicializadas podem ser referenciadas
+ * porque o valor dessa variável é necessário para o compilador de modelo.
+ */
+/** @dynamic */
+export declare class GIPIDomHandler {
+    static zIndex: number;
+    private static calculatedScrollbarWidth;
+    private static calculatedScrollbarHeight;
+    private static browser;
+    static addClass(element: any, className: string): void;
+    static addMultipleClasses(element: any, className: string): void;
+    static removeClass(element: any, className: string): void;
+    static hasClass(element: any, className: string): boolean;
+    static siblings(element: any): any;
+    static find(element: any, selector: string): any[];
+    static findSingle(element: any, selector: string): any;
+    static index(element: any): number;
+    static indexWithinGroup(element: any, attributeName: string): number;
+    static appendOverlay(overlay: any, target: any, appendTo?: any): void;
+    static alignOverlay(overlay: any, target: any, appendTo?: any, calculateMinWidth?: boolean): void;
+    static relativePosition(element: any, target: any): void;
+    static absolutePosition(element: any, target: any): void;
+    static getParents(element: any, parents?: any): any;
+    static getScrollableParents(element: any): any[];
+    static getHiddenElementOuterHeight(element: any): number;
+    static getHiddenElementOuterWidth(element: any): number;
+    static getHiddenElementDimensions(element: any): any;
+    static scrollInView(container: any, item: any): void;
+    static fadeIn(element: any, duration: number): void;
+    static fadeOut(element: any, ms: number): void;
+    static getWindowScrollTop(): number;
+    static getWindowScrollLeft(): number;
+    static matches(element: any, selector: string): boolean;
+    static getOuterWidth(el: any, margin?: any): number;
+    static getHorizontalPadding(el: any): number;
+    static getHorizontalMargin(el: any): number;
+    static innerWidth(el: any): number;
+    static width(el: any): number;
+    static getInnerHeight(el: any): number;
+    static getOuterHeight(el: any, margin?: any): number;
+    static getHeight(el: any): number;
+    static getWidth(el: any): number;
+    static getViewport(): {
+        width: number;
+        height: number;
+    };
+    static getOffset(el: any): {
+        top: any;
+        left: any;
+    };
+    static replaceElementWith(element: any, replacementElement: any): any;
+    static getUserAgent(): string;
+    static isIE(): boolean;
+    static isIOS(): boolean;
+    static isAndroid(): boolean;
+    static isTouchDevice(): boolean;
+    static appendChild(element: any, target: any): void;
+    static removeChild(element: any, target: any): void;
+    static removeElement(element: Element): void;
+    static isElement(obj: any): boolean;
+    static calculateScrollbarWidth(el?: HTMLElement): number;
+    static calculateScrollbarHeight(): number;
+    static invokeElementMethod(element: any, methodName: string, args?: any[]): void;
+    static clearSelection(): void;
+    static getBrowser(): any;
+    static resolveUserAgent(): {
+        browser: string;
+        version: string;
+    };
+    static isInteger(value: any): boolean;
+    static isHidden(element: HTMLElement): boolean;
+    static isVisible(element: HTMLElement): boolean;
+    static isExist(element: HTMLElement): ParentNode;
+    static focus(element: HTMLElement, options?: FocusOptions): void;
+    static getFocusableElements(element: HTMLElement): any[];
+    static getNextFocusableElement(element: HTMLElement, reverse?: boolean): any;
+    static generateZIndex(): number;
+    static getSelection(): string;
+    static getTargetElement(target: any, el?: HTMLElement): any;
+}