@dhtmlx/chart 9.3.3

package/codebase/types/ts-chart/sources/series/index.d.ts

@@ -0,0 +1,29 @@
+import area from "./Area";
+import bar from "./Bar";
+import xbar from "./BarX";
+import donut from "./Donut";
+import line from "./Line";
+import pie from "./Pie";
+import pie3D from "./Pie3D";
+import radar from "./Radar";
+import scatter from "./Scatter";
+import spline from "./Spline";
+import splineArea from "./SplineArea";
+import treeMap from "./TreeMap";
+import calendarHeatMap from "./CalendarHeatMap";
+declare const seriesTypes: {
+    line: typeof line;
+    spline: typeof spline;
+    area: typeof area;
+    splineArea: typeof splineArea;
+    scatter: typeof scatter;
+    pie: typeof pie;
+    pie3D: typeof pie3D;
+    donut: typeof donut;
+    radar: typeof radar;
+    bar: typeof bar;
+    xbar: typeof xbar;
+    treeMap: typeof treeMap;
+    calendarHeatMap: typeof calendarHeatMap;
+};
+export default seriesTypes;

package/codebase/types/ts-chart/sources/shapes/legend.d.ts

@@ -0,0 +1,2 @@
+export declare function legendShape(form: any, item: any): any;
+export declare function legendTicks(form: any, item: any): any[];

package/codebase/types/ts-chart/sources/shapes/line.d.ts

@@ -0,0 +1,7 @@
+import { PointType } from "../types";
+export declare function getHelper(type: PointType): any;
+export declare function getHTMLHelper(type: PointType): any;
+type drawFn = (x: number, y: number, id: string) => any;
+export declare function getShadeHelper(type: PointType, color: string): drawFn;
+export declare function getShadeHTMLHelper(type: PointType, color: string): drawFn;
+export {};

package/codebase/types/ts-chart/sources/types.d.ts

@@ -0,0 +1,301 @@
+import { IEventSystem } from "../../ts-common/events";
+import { DataCollection, DataEvents, IDataEventsHandlersMap } from "../../ts-data";
+import { IFitPosition } from "../../ts-common/html";
+export interface IChart {
+    events: IEventSystem<DataEvents | ChartEvents, IDataEventsHandlersMap & IChartEventHandlersMap>;
+    data: DataCollection;
+    eachSeries(handler: (seria: ISeria) => any): any[];
+    setConfig(config: IChartConfig): void;
+    paint(): void;
+    getSeries(id: string): ISeria;
+}
+export interface IChartConfig {
+    type?: TChartType;
+    css?: string;
+    barWidth?: number;
+    scales?: IScalesConfig;
+    legend?: ILegendConfig;
+    series?: SeriaConfig[];
+    maxPoints?: number;
+    data?: DataCollection<any> | any[];
+    exportStyles?: boolean | string[];
+}
+export type TChartType = "bar" | "line" | "spline" | "scatter" | "area" | "donut" | "pie" | "pie3D" | "radar" | "xbar" | "splineArea" | "treeMap" | "calendarHeatMap";
+export declare enum ChartEvents {
+    toggleSeries = "toggleSeries",
+    chartMouseMove = "chartMouseMove",
+    chartMouseLeave = "chartMouseLeave",
+    resize = "resize",
+    serieClick = "serieClick",
+    seriaMouseMove = "seriaMouseMove",
+    seriaMouseLeave = "seriaMouseLeave"
+}
+export interface IChartEventHandlersMap {
+    [key: string]: (...args: any[]) => any;
+    [ChartEvents.toggleSeries]: (id: string, pieLike: object | undefined) => void;
+    [ChartEvents.chartMouseMove]: (x: number, y: number, left: number, top: number) => void;
+    [ChartEvents.chartMouseLeave]: () => void;
+    [ChartEvents.resize]: (width: number, height: number) => void;
+    [ChartEvents.serieClick]: (id: string, value: string) => void;
+    [ChartEvents.seriaMouseMove]: (id: string, value: string, e: MouseEvent) => void;
+    [ChartEvents.seriaMouseLeave]: (id: string, value: string) => void;
+}
+export interface IChartSeries {
+    [id: string]: ISeria;
+}
+export interface ISeria extends ILikeSeria {
+    id: string;
+    config: ISeriaConfig;
+    toggle(id?: string): void;
+    addScale(type: ScaleType, scale: IScale): void;
+    getPoints(): PointData[];
+    getTooltipText(id: string): string;
+    getTooltipType(id: string, x?: number, y?: number): TooltipType;
+    getClosest(x: number, y: number): [number, number, number, string];
+    getClosestVertical(x: number): [number, number, number, string, number];
+}
+export type TreeDirectionType = "asc" | "desc";
+export interface ISeriaConfig {
+    id?: string;
+    type?: TChartType;
+    value?: string;
+    valueY?: string;
+    label?: ((item: ISeriaConfig) => string) | string;
+    pointType?: PointType;
+    legendType?: LegendType;
+    scales?: ScaleType[];
+    active?: boolean;
+    pointColor?: string;
+    dashed?: boolean;
+    stroke?: string;
+    strokeWidth?: number;
+    barWidth?: number;
+    css?: string;
+    fill?: string;
+    color?: string;
+    alpha?: number;
+    gradient?: Gradient;
+    showText?: boolean;
+    showTextRotate?: number | string;
+    showTextTemplate?: (points: any) => string;
+    valueTemplate?: (value: number) => string;
+    tooltip?: boolean;
+    tooltipType?: TooltipType;
+    tooltipTemplate?: (points: any[]) => string;
+    direction?: TreeDirectionType;
+    treeSeries?: ITreeSeries[];
+    baseLine?: number;
+    stacked?: boolean;
+}
+export type SeriaConfig = ISeriaConfig | INoScaleConfig;
+export interface IScale extends IComposable {
+    locator?: Locator;
+    add(chart: ILikeSeria): void;
+    point(item: object | number): number;
+    getSize(): number;
+    addPadding(): void;
+}
+export interface IScaleConfig extends IAxisCreatorConfig {
+    type?: ScaleType;
+    title?: string;
+    text?: SmartLocator;
+    textTemplate?: <T>(value: T) => string;
+    size?: number;
+    scalePadding?: number;
+    scaleRotate?: number;
+    textPadding?: number;
+    hidden?: boolean;
+    grid?: boolean;
+    dashed?: boolean;
+    targetLine?: number | string;
+    targetValue?: number;
+    showText?: boolean;
+    locator?: SmartLocator;
+}
+export type ScaleType = "left" | "right" | "top" | "bottom" | "radial";
+export interface IScales {
+    left?: IScale | ITextScale;
+    right?: IScale | ITextScale;
+    top?: IScale | ITextScale;
+    bottom?: IScale | ITextScale;
+    radial?: IScale;
+}
+export interface IScalesConfig {
+    left?: IScaleConfig | boolean;
+    right?: IScaleConfig | boolean;
+    top?: IScaleConfig | boolean;
+    bottom?: IScaleConfig | boolean;
+    radial?: IRadialScaleConfig;
+}
+export interface ILegendConfig {
+    values?: {
+        id?: SmartLocator;
+        text: SmartLocator;
+        color: SmartLocator;
+        alpha?: SmartLocator;
+        positiveColor?: SmartLocator;
+        negativeColor?: SmartLocator;
+        minValue?: number;
+        maxValue?: number;
+        value?: string;
+        step?: number;
+        tick?: number;
+        majorTick?: number;
+        tickTemplate?: <T>(value: T) => string;
+    };
+    size?: number;
+    form?: Shape;
+    type?: LegendType;
+    itemPadding?: number;
+    halign?: HorizontalPosition;
+    valign?: VerticalPosition;
+    series?: string[];
+    treeSeries?: ITreeSeries[];
+    margin?: number;
+    direction?: LegendDirection;
+    $seriesInfo?: ISeria[];
+    $sizes?: LegendSizes;
+}
+export interface ITreeSeries {
+    less?: number | string;
+    from?: number | string;
+    to?: number | string;
+    greater?: number | string;
+    color?: string;
+    active?: boolean;
+    id?: string;
+    name?: string;
+}
+export interface ILegendDrawData {
+    id: string;
+    alpha: number;
+    text: string;
+    fill: string;
+    active?: boolean;
+    color?: string;
+    minValue?: number;
+    maxValue?: number;
+    negativeColor?: string;
+    positiveColor?: string;
+    step?: number;
+    tick?: number;
+    majorTick?: number;
+    tickTemplate?: <T>(value: T) => string;
+}
+export interface IComposable {
+    paint(width: number, height: number, prev?: PointData[]): object;
+    paintformAndMarkers?(width: number, height: number, prev?: PointData[]): [object, object];
+    dataReady?(prev?: PointData[]): PointData[];
+    scaleReady?(sizes: IFitPosition): void;
+    destructor?(): void;
+}
+export interface IComposeLayer {
+    add(obj: any): void;
+    clear(): void;
+    getSizes(): IFitPosition;
+    toVDOM(width: number, height: number): void;
+}
+export interface IRadarConfig extends ISeriaConfig {
+    radius?: number;
+    paddings?: number;
+    scales: ScaleType[];
+}
+export interface IRadialScaleConfig extends IScaleConfig {
+    value?: string;
+    zebra?: boolean;
+    showAxis?: boolean;
+}
+export interface IRadarScaleDrawData {
+    scales: string[];
+    axis: number[];
+    realAxis: number[];
+    zebra: boolean;
+    attribute: string;
+}
+export interface ITreeMapConfig extends ISeriaConfig {
+    paddings?: number;
+    text?: string;
+}
+export interface ICalendarHeatMapConfig extends ISeriaConfig {
+    paddings?: number;
+    date?: string;
+    dateFormat?: string;
+    weekStart?: "saturday" | "sunday" | "monday";
+    positiveColor?: SmartLocator;
+    negativeColor?: SmartLocator;
+    minValue?: number;
+    maxValue?: number;
+    startDate?: string | Date;
+    endDate?: string | Date;
+    days?: string[];
+    months?: string[];
+}
+export interface IAxisCreatorConfig {
+    max?: number;
+    min?: number;
+    log?: boolean;
+    padding?: number;
+    maxTicks?: number;
+    type?: string;
+}
+export interface IAxisScale {
+    min: number;
+    max: number;
+    steps: number[];
+}
+export interface IAxisCreator {
+    config: IAxisCreatorConfig;
+    getScale(): IAxisScale;
+}
+export interface IAxisLike<T> {
+    steps: T[];
+    max: number;
+    min?: number;
+}
+export interface INoScaleConfig extends ISeriaConfig {
+    text?: SmartLocator;
+    value?: string;
+    useLines?: boolean;
+    subType?: NoScaleSubType;
+    stroke?: string;
+    monochrome?: string;
+    paddings?: number;
+}
+export type PointType = "circle" | "rect" | "triangle" | "rhombus" | "simpleRect" | "simpleCircle" | "empty";
+export type Gradient = (color: string) => any;
+export type TooltipType = "simple" | "right" | "left" | "top" | "bot";
+export type SvgElement = any;
+export type Shape = "rect" | "circle" | "line";
+export type HorizontalPosition = "left" | "center" | "right";
+export type VerticalPosition = "top" | "middle" | "bottom";
+export type LegendDirection = "row" | "column";
+export type LegendType = "groupName" | "range" | "scale";
+export type LegendSizes = {
+    width: number;
+    height: number;
+};
+export interface ILikeSeria extends IComposable {
+    getPoints(): PointData[];
+    seriesShift?(size?: number): number;
+}
+export interface ITextScale extends IScale {
+    addPadding(): void;
+}
+export type Locator = (item: any) => any;
+export type DrawPoint = (x: number, y: number, ref?: string) => any;
+export type NoScaleSubType = "basic" | "percentOnly" | "valueOnly";
+export type SmartLocator = Locator | string;
+export interface IStacker extends IComposable, ILikeSeria {
+    add(seria: ISeria): void;
+}
+export type PointData = [number, number, string, (number | string)?, number?, TreePointData?];
+export type TreePointData = {
+    items: PointData[];
+};
+export interface IGridRenderConfig {
+    targetLine?: number;
+    dashed: boolean;
+    grid: boolean;
+    targetValue?: number;
+    hidden?: boolean;
+}

package/codebase/types/ts-combobox/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./sources/Combobox";
+export * from "./sources/ProCombobox";
+export * from "./sources/types";

package/codebase/types/ts-combobox/sources/Combobox.d.ts

@@ -0,0 +1,53 @@
+import { VNode } from "../../ts-common/dom";
+import { IEventSystem } from "../../ts-common/events";
+import { View } from "../../ts-common/view";
+import { DataCollection, DataEvents, IDataEventsHandlersMap, IDataItem } from "../../ts-data";
+import { Layout } from "../../ts-layout";
+import { List } from "../../ts-list";
+import { Popup } from "../../ts-popup";
+import { Id, IHandlers } from "../../ts-common/types";
+import { ComboboxEvents, ICombobox, IComboboxConfig, IComboboxEventHandlersMap, State } from "./types";
+export declare const $template: VNode;
+export declare class Combobox extends View implements ICombobox {
+    data: DataCollection;
+    config: IComboboxConfig;
+    events: IEventSystem<DataEvents | ComboboxEvents, IComboboxEventHandlersMap | IDataEventsHandlersMap>;
+    list: List;
+    popup: Popup;
+    protected _helper: Popup;
+    private _keyListener;
+    protected _layout: Layout;
+    private _isPopupConfiqureted;
+    private _state;
+    protected _handlers: IHandlers;
+    constructor(element: HTMLElement | string, config: IComboboxConfig);
+    focus(): void | boolean;
+    blur(): void | boolean;
+    enable(): void;
+    disable(): void;
+    isDisabled(): boolean;
+    clear(): void | boolean;
+    getValue<T extends boolean = false>(asArray?: T): T extends true ? Id[] : Id;
+    setValue(ids: Id[] | Id, silent?: boolean): void | boolean;
+    addOption<T extends IDataItem>(value: T | string, join?: boolean): void;
+    destructor(): void;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    setState(state: State): void;
+    private _setValue;
+    protected _createLayout(): void;
+    private _initHandlers;
+    private _initEvents;
+    private _showOptions;
+    private _configurePopup;
+    private _hideOptions;
+    private _filter;
+    private _findBest;
+    private _exsistId;
+    private _draw;
+    private _drawSelectedItems;
+    private _drawImageOrIcon;
+    private _getItemText;
+    private _updateSelectedItem;
+    private _changePopupPosition;
+    private _updatePopup;
+}

package/codebase/types/ts-combobox/sources/ProCombobox.d.ts

@@ -0,0 +1,6 @@
+import { Combobox } from "./Combobox";
+import { IComboboxConfig } from "./types";
+export declare class ProCombobox extends Combobox {
+    constructor(element: HTMLElement | string, config: IComboboxConfig);
+    protected _createLayout(): void;
+}

package/codebase/types/ts-combobox/sources/helper.d.ts

@@ -0,0 +1,4 @@
+export declare function selectAllView(): any;
+export declare function unselectAllView(): any;
+export declare function emptyListView(value?: string): any;
+export declare function emptyListHeight(value: string, width: number): number;

package/codebase/types/ts-combobox/sources/keyListener.d.ts

@@ -0,0 +1,14 @@
+export declare class KeyListener {
+    private _isActive;
+    private _sequence;
+    private _currentAction;
+    private _clearTimeout;
+    private _handler;
+    constructor();
+    startNewListen(action: (seq: string) => any): void;
+    endListen(): void;
+    reset(): void;
+    destructor(): void;
+    private _change;
+    private _addClearTimeout;
+}

package/codebase/types/ts-combobox/sources/locales/en.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    notFound: string;
+    selectAll: string;
+    unselectAll: string;
+    selectedItems: string;
+    createItem: string;
+};
+export default _default;

package/codebase/types/ts-combobox/sources/types.d.ts

@@ -0,0 +1,95 @@
+import { Id } from "../../ts-common/types";
+import { DataCollection, IDataItem } from "../../ts-data";
+export type ILabelPosition = "left" | "top";
+export interface IComboboxConfig {
+    data?: DataCollection<any> | any[];
+    disabled?: boolean;
+    readOnly?: boolean;
+    template?: (item: any) => string;
+    filter?: (item: any, input: string) => boolean;
+    multiselection?: boolean;
+    label?: string;
+    labelPosition?: ILabelPosition;
+    labelWidth?: string | number;
+    placeholder?: string;
+    selectAllButton?: boolean;
+    itemsCount?: boolean | ((count: number) => string);
+    itemHeight?: number | string;
+    virtual?: boolean;
+    listHeight?: number | string;
+    required?: boolean;
+    helpMessage?: string;
+    hiddenLabel?: boolean;
+    css?: string;
+    value?: Id | Id[];
+    newOptions?: boolean;
+    htmlEnable?: boolean;
+    eventHandlers?: {
+        [eventName: string]: {
+            [className: string]: (event: Event, id: Id) => void | boolean;
+        };
+    };
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    cellHeight?: number;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    help?: string;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    showItemsCount?: boolean | ((count: number) => string);
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    labelInline?: boolean;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    readonly?: boolean;
+}
+export declare enum ComboboxEvents {
+    beforeChange = "beforeChange",
+    change = "change",
+    focus = "focus",
+    blur = "blur",
+    keydown = "keydown",
+    input = "input",
+    beforeOpen = "beforeOpen",
+    afterOpen = "afterOpen",
+    beforeClose = "beforeClose",
+    afterClose = "afterClose",
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    open = "open",
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    close = "close"
+}
+export interface IComboboxEventHandlersMap {
+    [key: string]: (...args: any[]) => any;
+    [ComboboxEvents.beforeChange]: (ids: Id | Id[]) => boolean | void;
+    [ComboboxEvents.change]: (ids: Id | Id[]) => void;
+    [ComboboxEvents.focus]: () => void;
+    [ComboboxEvents.blur]: () => void;
+    [ComboboxEvents.keydown]: (event: KeyboardEvent, id: Id | undefined) => void;
+    [ComboboxEvents.input]: (value: string) => void;
+    [ComboboxEvents.beforeOpen]: () => boolean | void;
+    [ComboboxEvents.afterOpen]: () => void;
+    [ComboboxEvents.beforeClose]: () => boolean | void;
+    [ComboboxEvents.afterClose]: () => void;
+    [ComboboxEvents.open]: () => void;
+    [ComboboxEvents.close]: () => void;
+}
+export interface ICombobox {
+    disable(): void;
+    enable(): void;
+    isDisabled(): boolean;
+    destructor(): void;
+    paint(): void;
+    clear(): void;
+    focus(): void;
+    blur(): void;
+    getValue(asArray?: boolean): Id[] | Id;
+    setValue(ids: Id[] | Id): void;
+    addOption<T extends IDataItem>(value: T | string, join?: boolean): void;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    setState(state: State): void;
+}
+export declare enum ComboState {
+    default = 0,
+    error = 1,
+    success = 2
+}
+/** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+export type State = "success" | "error" | "default";

package/codebase/types/ts-common/FocusManager.d.ts

@@ -0,0 +1,15 @@
+export interface IFocusManager {
+    getFocusId(): string;
+    setFocusId(id: string): void;
+}
+declare class FocusManager implements IFocusManager {
+    private _activeWidgetId;
+    private _initHandler;
+    private _removeFocusClass;
+    private _addFocusClass;
+    constructor();
+    getFocusId(): string;
+    setFocusId(id: string): void;
+}
+export declare const focusManager: FocusManager;
+export {};

package/codebase/types/ts-common/KeyManager.d.ts

@@ -0,0 +1,19 @@
+import { anyFunction } from "./types";
+export interface IKeyManager {
+    destructor(): void;
+    addHotKey(key: string, handler: any): void;
+    removeHotKey(key?: string, context?: any): void;
+    exist(key: string): boolean;
+    getKeyStorageLength(): number;
+}
+export declare class KeyManager implements IKeyManager {
+    private _keysStorage;
+    private _beforeCall;
+    private _initHandler;
+    constructor(beforeCall?: (e: Event, focus: any) => boolean);
+    destructor(): void;
+    addHotKey(key: string, handler: any): void;
+    removeHotKey(key?: string, handler?: anyFunction): void;
+    exist(key: string): boolean;
+    getKeyStorageLength(): number;
+}

package/codebase/types/ts-common/ScrollView.d.ts

@@ -0,0 +1,40 @@
+import { anyFunction } from "./types";
+interface IScrollViewConfig {
+    enable: boolean;
+    autoHide: boolean;
+    timeout: number;
+    scrollHandler: anyFunction;
+}
+export declare const scrollViewConfig: IScrollViewConfig;
+export interface IScrollView {
+    config: IScrollViewConfig;
+    enable(): void;
+    disable(): void;
+    render(nods?: any[]): any;
+    update(): void;
+}
+export declare class ScrollView implements IScrollView {
+    config: IScrollViewConfig;
+    private _getRootView;
+    private _scrollYTop;
+    private _scrollXLeft;
+    private _runnerYTop;
+    private _runnerXLeft;
+    private _runnerHeight;
+    private _runnerWidth;
+    private _visibleYArea;
+    private _visibleXArea;
+    private _scrollWidth;
+    private _scrollHeight;
+    private _wheelName;
+    private _handlers;
+    private _autoHideFunc;
+    private _uid;
+    constructor(getRootView: any, config?: {});
+    enable(): void;
+    disable(): void;
+    render(element: any, uid?: string): any;
+    update(): void;
+    private _getRefs;
+}
+export {};

package/codebase/types/ts-common/core.d.ts

@@ -0,0 +1,40 @@
+type fn<T extends any[], K> = (...args: T) => K;
+type anyFunction = fn<any[], any>;
+export declare function uid(): string;
+export declare function extendComponent(target: any, source: any): any;
+export declare function extend(target: any, source: any, deep?: boolean): any;
+interface IOBj {
+    [key: string]: any;
+}
+export declare function copy(source: IOBj, withoutInner?: boolean): IOBj;
+export declare function naturalSort(arr: any): any[];
+export declare function findIndex<T = any>(arr: T[], predicate: (obj: T) => boolean): number;
+export declare function isExistValue(target: number | string, value: number | string): boolean;
+export declare function singleOuterClick(fn: (e: MouseEvent) => boolean): void;
+export declare function detectWidgetClick(widgetId: string, cb: (inner: boolean) => void): () => void;
+export declare function unwrapBox<T>(box: T | T[]): T;
+export declare function wrapBox<T>(unboxed: T | T[]): T[];
+export declare function isDefined<T>(some: T): boolean;
+export declare function isId<T>(some: T): boolean;
+export declare function range(from: number, to: number): number[];
+export declare function isNumeric(val: any): boolean;
+export declare function downloadFile(data: Blob | string, filename: string, mimeType?: string): void;
+export declare function debounce(func: anyFunction, wait: number, immediate?: boolean): (...args: any[]) => void;
+export declare function compare(obj1: any, obj2: any): boolean;
+export declare const isType: (value: any) => string;
+export declare const isEmptyObj: (obj: any) => boolean;
+export declare const getMaxArrayNumber: (array: number[]) => number;
+export declare const getMinArrayNumber: (array: number[]) => number;
+export interface IContainerConfig {
+    lineHeight?: number;
+    font?: string;
+}
+export declare const getStringWidth: (value: string, config?: IContainerConfig) => number;
+export declare const rgbToHex: (color: string) => string;
+export declare function getCloneObject(obj: any): any;
+export declare function getTextLines({ ctx, text, maxWidth }: {
+    ctx: any;
+    text: any;
+    maxWidth: any;
+}): string[];
+export {};

package/codebase/types/ts-common/date.d.ts

@@ -0,0 +1,34 @@
+export declare const locale: {
+    monthsShort: string[];
+    months: string[];
+    daysShort: string[];
+    days: string[];
+    cancel: string;
+};
+export declare function getFormattedDate(format: string, date: Date): string;
+export declare function getExcelDate(date: Date): number;
+export declare function stringToDate(str: string, format: string, validate?: boolean): any;
+export declare class DateHelper {
+    static nullTimestampDate: Date;
+    static copy(d: Date): Date;
+    static fromYear(year: number): Date;
+    static fromYearAndMonth(year: number, month: number): Date;
+    static weekStart(d: Date, firstWeekday: -1 | 0 | 1): Date;
+    static monthStart(d: Date): Date;
+    static yearStart(d: Date): Date;
+    static dayStart(d: Date): Date;
+    static addDay(d: Date, count?: number): Date;
+    static addMonth(d: Date, count?: number): Date;
+    static addYear(d: Date, count?: number): Date;
+    static withHoursAndMinutes(d: Date, hours: number, minutes: number, dateFormat: boolean): Date;
+    static setMonth(d: Date, month: number): void;
+    static setYear(d: Date, year: number): void;
+    static mergeHoursAndMinutes(source: Date, target: Date): Date;
+    static isWeekEnd(d: Date): boolean;
+    static getTwelweYears(d: Date): number[];
+    static getDayOrdinal(d: Date): number;
+    static getWeekNumber(d: Date): number;
+    static isSameDay(d1: Date, d2: Date): boolean;
+    static toDateObject(date: Date | string, dateFormat: string): Date;
+}
+export declare function stripTime(d: Date, full?: boolean): Date;