@schneideress/dashboardframework 0.0.1

package/gridster/index.d.ts

@@ -0,0 +1,11 @@
+export { GridsterComponent } from './lib/gridster.component';
+export { GridsterItemComponent } from './lib/gridsterItem.component';
+export { GridsterItem } from './lib/gridsterItem.interface';
+export { GridsterItemComponentInterface } from './lib/gridsterItemComponent.interface';
+export { GridsterComponentInterface } from './lib/gridster.interface';
+export { GridsterConfig, GridType, DisplayGrid, CompactType, Draggable, Resizable, PushDirections } from './lib/gridsterConfig.interface';
+export { GridsterConfigService } from './lib/gridsterConfig.constant';
+export { GridsterModule } from './lib/gridster.module';
+export { GridsterPush } from './lib/gridsterPush.service';
+export { GridsterPushResize } from './lib/gridsterPushResize.service';
+export { GridsterSwap } from './lib/gridsterSwap.service';

package/gridster/lib/gridster.component.d.ts

@@ -0,0 +1,67 @@
+import { ChangeDetectorRef, ElementRef, NgZone, OnChanges, OnDestroy, OnInit, Renderer2, SimpleChanges } from '@angular/core';
+import { GridsterConfig } from './gridsterConfig.interface';
+import { GridsterEmptyCell } from './gridsterEmptyCell.service';
+import { GridsterCompact } from './gridsterCompact.service';
+import { GridsterConfigS } from './gridsterConfigS.interface';
+import { GridsterComponentInterface } from './gridster.interface';
+import { GridsterItemComponentInterface } from './gridsterItemComponent.interface';
+import { GridsterRenderer } from './gridsterRenderer.service';
+import { GridsterItem } from './gridsterItem.interface';
+export declare class GridsterComponent implements OnInit, OnChanges, OnDestroy, GridsterComponentInterface {
+    renderer: Renderer2;
+    cdRef: ChangeDetectorRef;
+    zone: NgZone;
+    options: GridsterConfig;
+    calculateLayoutDebounce: () => void;
+    movingItem: GridsterItem | null;
+    previewStyle: () => void;
+    el: any;
+    $options: GridsterConfigS;
+    mobile: boolean;
+    curWidth: number;
+    curHeight: number;
+    grid: Array<GridsterItemComponentInterface>;
+    columns: number;
+    rows: number;
+    curColWidth: number;
+    curRowHeight: number;
+    gridColumns: any[];
+    gridRows: any[];
+    windowResize: (() => void) | null;
+    dragInProgress: boolean;
+    emptyCell: GridsterEmptyCell;
+    compact: GridsterCompact;
+    gridRenderer: GridsterRenderer;
+    constructor(el: ElementRef, renderer: Renderer2, cdRef: ChangeDetectorRef, zone: NgZone);
+    static checkCollisionTwoItems(item: GridsterItem, item2: GridsterItem): boolean;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    getCurrentRowHeight(): number;
+    resize(): void;
+    setOptions(): void;
+    optionsChanged(): void;
+    ngOnDestroy(): void;
+    onResize(): void;
+    checkIfToResize(): boolean;
+    setGridSize(): void;
+    setGridDimensions(): void;
+    calculateLayout(): void;
+    updateGrid(): void;
+    addItem(itemComponent: GridsterItemComponentInterface): void;
+    removeItem(itemComponent: GridsterItemComponentInterface): void;
+    checkCollision(item: GridsterItem): GridsterItemComponentInterface | boolean;
+    checkGridCollision(item: GridsterItem): boolean;
+    findItemWithItem(item: GridsterItem): GridsterItemComponentInterface | boolean;
+    findItemsWithItem(item: GridsterItem): Array<GridsterItemComponentInterface>;
+    autoPositionItem(itemComponent: GridsterItemComponentInterface): void;
+    getNextPossiblePosition(newItem: GridsterItem, startingFrom?: {
+        y?: number;
+        x?: number;
+    }): boolean;
+    getFirstPossiblePosition(item: GridsterItem): GridsterItem;
+    getLastPossiblePosition(item: GridsterItem): GridsterItem;
+    pixelsToPositionX(x: number, roundingMethod: Function, noLimit?: boolean): number;
+    pixelsToPositionY(y: number, roundingMethod: Function, noLimit?: boolean): number;
+    positionXToPixels(x: number): number;
+    positionYToPixels(y: number): number;
+}

package/gridster/lib/gridster.interface.d.ts

@@ -0,0 +1,46 @@
+import { GridsterConfigS } from './gridsterConfigS.interface';
+import { ChangeDetectorRef, NgZone, Renderer2 } from '@angular/core';
+import { GridsterEmptyCell } from './gridsterEmptyCell.service';
+import { GridsterCompact } from './gridsterCompact.service';
+import { GridsterConfig } from './gridsterConfig.interface';
+import { GridsterItem } from './gridsterItem.interface';
+import { GridsterItemComponentInterface } from './gridsterItemComponent.interface';
+import { GridsterRenderer } from './gridsterRenderer.service';
+export declare abstract class GridsterComponentInterface {
+    $options: GridsterConfigS;
+    grid: Array<GridsterItemComponentInterface>;
+    checkCollision: (item: GridsterItem) => GridsterItemComponentInterface | boolean;
+    positionXToPixels: (x: number) => number;
+    pixelsToPositionX: (x: number, roundingMethod: (x: number) => number, noLimit?: boolean) => number;
+    positionYToPixels: (y: number) => number;
+    pixelsToPositionY: (y: number, roundingMethod: (x: number) => number, noLimit?: boolean) => number;
+    findItemWithItem: (item: GridsterItem) => GridsterItemComponentInterface | boolean;
+    findItemsWithItem: (item: GridsterItem) => Array<GridsterItemComponentInterface>;
+    checkGridCollision: (item: GridsterItem) => boolean;
+    el: any;
+    renderer: Renderer2;
+    gridRenderer: GridsterRenderer;
+    cdRef: ChangeDetectorRef;
+    options: GridsterConfig;
+    calculateLayoutDebounce: () => void;
+    updateGrid: () => void;
+    movingItem: GridsterItem | null;
+    addItem: (item: GridsterItemComponentInterface) => void;
+    removeItem: (item: GridsterItemComponentInterface) => void;
+    previewStyle: (drag?: boolean) => void;
+    mobile: boolean;
+    curWidth: number;
+    curHeight: number;
+    columns: number;
+    rows: number;
+    curColWidth: number;
+    curRowHeight: number;
+    windowResize: (() => void) | null;
+    setGridDimensions: (() => void);
+    dragInProgress: boolean;
+    emptyCell: GridsterEmptyCell;
+    compact: GridsterCompact;
+    zone: NgZone;
+    gridRows: Array<number>;
+    gridColumns: Array<number>;
+}

package/gridster/lib/gridster.module.d.ts

@@ -0,0 +1,2 @@
+export declare class GridsterModule {
+}

package/gridster/lib/gridsterCompact.service.d.ts

@@ -0,0 +1,15 @@
+import { GridsterComponentInterface } from './gridster.interface';
+import { GridsterItem } from './gridsterItem.interface';
+export declare class GridsterCompact {
+    private gridster;
+    constructor(gridster: GridsterComponentInterface);
+    destroy(): void;
+    checkCompact(): void;
+    checkCompactItem(item: GridsterItem): void;
+    checkCompactUp(): void;
+    moveUpTillCollision(item: GridsterItem): boolean;
+    checkCompactLeft(): void;
+    checkCompactRight(): void;
+    moveLeftTillCollision(item: GridsterItem): boolean;
+    moveRightTillCollision(item: any): boolean;
+}

package/gridster/lib/gridsterConfig.constant.d.ts

@@ -0,0 +1,2 @@
+import { GridsterConfig } from './gridsterConfig.interface';
+export declare const GridsterConfigService: GridsterConfig;

package/gridster/lib/gridsterConfig.interface.d.ts

@@ -0,0 +1,133 @@
+import { GridsterItem } from './gridsterItem.interface';
+import { GridsterItemComponentInterface } from './gridsterItemComponent.interface';
+import { GridsterComponentInterface } from './gridster.interface';
+export declare type gridTypes = 'fit' | 'scrollVertical' | 'scrollHorizontal' | 'fixed' | 'verticalFixed' | 'horizontalFixed';
+export declare type displayGrids = 'always' | 'onDrag&Resize' | 'none';
+export declare type compactTypes = 'none' | 'compactUp' | 'compactLeft' | 'compactUp&Left' | 'compactLeft&Up' | 'compactRight' | 'compactUp&Right' | 'compactRight&Up';
+export declare enum GridType {
+    Fit = "fit",
+    ScrollVertical = "scrollVertical",
+    ScrollHorizontal = "scrollHorizontal",
+    Fixed = "fixed",
+    VerticalFixed = "verticalFixed",
+    HorizontalFixed = "horizontalFixed"
+}
+export declare enum DisplayGrid {
+    Always = "always",
+    OnDragAndResize = "onDrag&Resize",
+    None = "none"
+}
+export declare enum CompactType {
+    None = "none",
+    CompactUp = "compactUp",
+    CompactLeft = "compactLeft",
+    CompactUpAndLeft = "compactUp&Left",
+    CompactLeftAndUp = "compactLeft&Up",
+    CompactRight = "compactRight",
+    CompactUpAndRight = "compactUp&Right",
+    CompactRightAndUp = "compactRight&Up"
+}
+export interface GridsterConfig {
+    gridType?: gridTypes;
+    fixedColWidth?: number;
+    fixedRowHeight?: number;
+    keepFixedHeightInMobile?: boolean;
+    keepFixedWidthInMobile?: boolean;
+    setGridSize?: boolean;
+    compactType?: compactTypes;
+    mobileBreakpoint?: number;
+    minCols?: number;
+    maxCols?: number;
+    minRows?: number;
+    maxRows?: number;
+    defaultItemCols?: number;
+    defaultItemRows?: number;
+    maxItemCols?: number;
+    maxItemRows?: number;
+    minItemCols?: number;
+    minItemRows?: number;
+    minItemArea?: number;
+    maxItemArea?: number;
+    margin?: number;
+    outerMargin?: boolean;
+    outerMarginTop?: number | null;
+    outerMarginRight?: number | null;
+    outerMarginBottom?: number | null;
+    outerMarginLeft?: number | null;
+    useTransformPositioning?: boolean;
+    scrollSensitivity?: number | null;
+    scrollSpeed?: number;
+    initCallback?: (gridster: GridsterComponentInterface) => void;
+    destroyCallback?: (gridster: GridsterComponentInterface) => void;
+    gridSizeChangedCallback?: (gridster: GridsterComponentInterface) => void;
+    itemChangeCallback?: (item: GridsterItem, itemComponent: GridsterItemComponentInterface) => void;
+    itemResizeCallback?: (item: GridsterItem, itemComponent: GridsterItemComponentInterface) => void;
+    itemInitCallback?: (item: GridsterItem, itemComponent: GridsterItemComponentInterface) => void;
+    itemRemovedCallback?: (item: GridsterItem, itemComponent: GridsterItemComponentInterface) => void;
+    itemValidateCallback?: (item: GridsterItem) => boolean;
+    draggable?: Draggable;
+    resizable?: Resizable;
+    swap?: boolean;
+    pushItems?: boolean;
+    disablePushOnDrag?: boolean;
+    disablePushOnResize?: boolean;
+    disableAutoPositionOnConflict?: boolean;
+    pushDirections?: PushDirections;
+    pushResizeItems?: boolean;
+    displayGrid?: displayGrids;
+    disableWindowResize?: boolean;
+    disableWarnings?: boolean;
+    scrollToNewItems?: boolean;
+    enableEmptyCellClick?: boolean;
+    enableEmptyCellContextMenu?: boolean;
+    enableEmptyCellDrop?: boolean;
+    enableEmptyCellDrag?: boolean;
+    emptyCellClickCallback?: (event: MouseEvent, item: GridsterItem) => void;
+    emptyCellContextMenuCallback?: (event: MouseEvent, item: GridsterItem) => void;
+    emptyCellDropCallback?: (event: MouseEvent, item: GridsterItem) => void;
+    emptyCellDragCallback?: (event: MouseEvent, item: GridsterItem) => void;
+    emptyCellDragMaxCols?: number;
+    emptyCellDragMaxRows?: number;
+    ignoreMarginInRow?: boolean;
+    autoResizeonDrag?: boolean;
+    api?: {
+        resize?: () => void;
+        optionsChanged?: () => void;
+        getNextPossiblePosition?: (newItem: GridsterItem) => boolean;
+        getFirstPossiblePosition?: (item: GridsterItem) => GridsterItem;
+        getLastPossiblePosition?: (item: GridsterItem) => GridsterItem;
+        getCurrentRowHeight?: () => number;
+    };
+    [propName: string]: any;
+}
+export interface DragBase {
+    enabled?: boolean;
+    stop?: (item: GridsterItem, itemComponent: GridsterItemComponentInterface, event: MouseEvent) => Promise<any> | void;
+    start?: (item: GridsterItem, itemComponent: GridsterItemComponentInterface, event: MouseEvent) => void;
+    delayStart?: number;
+}
+export interface Draggable extends DragBase {
+    ignoreContentClass?: string;
+    ignoreContent?: boolean;
+    dragHandleClass?: string;
+    dropOverItems?: boolean;
+    dropOverItemsCallback?: (source: GridsterItem, target: GridsterItem, grid?: GridsterComponentInterface) => void;
+}
+export interface Resizable extends DragBase {
+    handles?: {
+        s: boolean;
+        e: boolean;
+        n: boolean;
+        w: boolean;
+        se: boolean;
+        ne: boolean;
+        sw: boolean;
+        nw: boolean;
+    };
+}
+export interface PushDirections {
+    north: boolean;
+    east: boolean;
+    south: boolean;
+    west: boolean;
+}

package/gridster/lib/gridsterConfigS.interface.d.ts

@@ -0,0 +1,93 @@
+import { compactTypes, displayGrids, gridTypes } from './gridsterConfig.interface';
+import { GridsterItem } from './gridsterItem.interface';
+import { GridsterComponentInterface } from './gridster.interface';
+export interface GridsterConfigS {
+    gridType: gridTypes;
+    fixedColWidth: number;
+    fixedRowHeight: number;
+    keepFixedHeightInMobile: boolean;
+    keepFixedWidthInMobile: boolean;
+    setGridSize: boolean;
+    compactType: compactTypes;
+    mobileBreakpoint: number;
+    minCols: number;
+    maxCols: number;
+    minRows: number;
+    maxRows: number;
+    defaultItemCols: number;
+    defaultItemRows: number;
+    maxItemCols: number;
+    maxItemRows: number;
+    minItemCols: number;
+    minItemRows: number;
+    minItemArea: number;
+    maxItemArea: number;
+    margin: number;
+    outerMargin: boolean;
+    outerMarginTop: number | null;
+    outerMarginRight: number | null;
+    outerMarginBottom: number | null;
+    outerMarginLeft: number | null;
+    useTransformPositioning: boolean;
+    scrollSensitivity: number;
+    scrollSpeed: number;
+    draggable: Draggable;
+    resizable: Resizable;
+    swap: boolean;
+    pushItems: boolean;
+    disablePushOnDrag: boolean;
+    disablePushOnResize: boolean;
+    disableAutoPositionOnConflict: boolean;
+    pushDirections: PushDirections;
+    pushResizeItems: boolean;
+    displayGrid: displayGrids;
+    disableWindowResize: boolean;
+    disableWarnings: boolean;
+    scrollToNewItems: boolean;
+    enableEmptyCellClick: boolean;
+    enableEmptyCellContextMenu: boolean;
+    enableEmptyCellDrop: boolean;
+    enableEmptyCellDrag: boolean;
+    emptyCellDragMaxCols: number;
+    emptyCellDragMaxRows: number;
+    ignoreMarginInRow: boolean;
+    api: {
+        resize: () => void;
+        optionsChanged: () => void;
+        getNextPossiblePosition: (newItem: GridsterItem) => boolean;
+        getFirstPossiblePosition: (item: GridsterItem) => GridsterItem;
+        getLastPossiblePosition: (item: GridsterItem) => GridsterItem;
+        getCurrentRowHeight: () => number;
+    };
+    [propName: string]: any;
+}
+export interface DragBase {
+    enabled: boolean;
+    delayStart: number;
+    [propName: string]: any;
+}
+export interface Draggable extends DragBase {
+    ignoreContentClass: string;
+    ignoreContent: boolean;
+    dragHandleClass: string;
+    dropOverItems: boolean;
+    dropOverItemsCallback: (source: GridsterItem, target: GridsterItem, grid?: GridsterComponentInterface) => void;
+}
+export interface Resizable extends DragBase {
+    handles: {
+        s: boolean;
+        e: boolean;
+        n: boolean;
+        w: boolean;
+        se: boolean;
+        ne: boolean;
+        sw: boolean;
+        nw: boolean;
+    };
+}
+export interface PushDirections {
+    north: boolean;
+    east: boolean;
+    south: boolean;
+    west: boolean;
+}

package/gridster/lib/gridsterDraggable.service.d.ts

@@ -0,0 +1,59 @@
+import { NgZone } from '@angular/core';
+import { GridsterSwap } from './gridsterSwap.service';
+import { GridsterPush } from './gridsterPush.service';
+import { GridsterItemComponentInterface } from './gridsterItemComponent.interface';
+import { GridsterComponentInterface } from './gridster.interface';
+export declare class GridsterDraggable {
+    private zone;
+    gridsterItem: GridsterItemComponentInterface;
+    gridster: GridsterComponentInterface;
+    lastMouse: {
+        clientX: number;
+        clientY: number;
+    };
+    offsetLeft: number;
+    offsetTop: number;
+    margin: number;
+    diffTop: number;
+    diffLeft: number;
+    top: number;
+    left: number;
+    height: number;
+    width: number;
+    positionX: number;
+    positionY: number;
+    positionXBackup: number;
+    positionYBackup: number;
+    enabled: boolean;
+    dragStartFunction: (event: any) => void;
+    dragFunction: (event: any) => void;
+    dragStopFunction: (event: any) => void;
+    mousemove: Function;
+    mouseup: Function;
+    mouseleave: Function;
+    cancelOnBlur: Function;
+    touchmove: Function;
+    touchend: Function;
+    touchcancel: Function;
+    mousedown: Function;
+    touchstart: Function;
+    push: GridsterPush;
+    swap: GridsterSwap;
+    path: Array<{
+        x: number;
+        y: number;
+    }>;
+    collision: GridsterItemComponentInterface | boolean;
+    constructor(gridsterItem: GridsterItemComponentInterface, gridster: GridsterComponentInterface, zone: NgZone);
+    destroy(): void;
+    dragStart(e: any): void;
+    dragMove(e: any): void;
+    calculateItemPositionFromMousePosition(e: any): void;
+    dragStop(e: any): void;
+    cancelDrag(): void;
+    makeDrag(): void;
+    checkforavailableSpaceintheArea(): import("./gridsterItem.interface").GridsterItem;
+    calculateItemPosition(): void;
+    toggle(): void;
+    dragStartDelay(e: any): void;
+}

package/gridster/lib/gridsterEmptyCell.service.d.ts

@@ -0,0 +1,29 @@
+import { GridsterItem } from './gridsterItem.interface';
+import { GridsterComponentInterface } from './gridster.interface';
+export declare class GridsterEmptyCell {
+    private gridster;
+    initialItem: GridsterItem | null;
+    emptyCellClick: Function | null;
+    emptyCellClickTouch: Function | null;
+    emptyCellContextMenu: Function | null;
+    emptyCellDrop: Function | null;
+    emptyCellDrag: Function | null;
+    emptyCellDragTouch: Function | null;
+    emptyCellMMove: Function;
+    emptyCellMMoveTouch: Function;
+    emptyCellUp: Function;
+    emptyCellUpTouch: Function;
+    emptyCellMove: Function | null;
+    emptyCellExit: Function | null;
+    constructor(gridster: GridsterComponentInterface);
+    destroy(): void;
+    updateOptions(): void;
+    emptyCellClickCb(e: any): void;
+    emptyCellContextMenuCb(e: any): void;
+    emptyCellDragDrop(e: any): void;
+    emptyCellDragOver(e: any): void;
+    emptyCellMouseDown(e: any): void;
+    emptyCellMouseMove(e: any): void;
+    emptyCellMouseUp(e: any): void;
+    getValidItemFromEvent(e: any, oldItem?: GridsterItem | null): GridsterItem | undefined;
+}

package/gridster/lib/gridsterItem.component.d.ts

@@ -0,0 +1,32 @@
+import { ElementRef, NgZone, OnDestroy, OnInit, Renderer2 } from '@angular/core';
+import { GridsterItem } from './gridsterItem.interface';
+import { GridsterDraggable } from './gridsterDraggable.service';
+import { GridsterResizable } from './gridsterResizable.service';
+import { GridsterItemComponentInterface } from './gridsterItemComponent.interface';
+import { GridsterComponent } from './gridster.component';
+export declare class GridsterItemComponent implements OnInit, OnDestroy, GridsterItemComponentInterface {
+    renderer: Renderer2;
+    private zone;
+    item: GridsterItem;
+    $item: GridsterItem;
+    el: any;
+    gridster: GridsterComponent;
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+    drag: GridsterDraggable;
+    resize: GridsterResizable;
+    notPlaced: boolean;
+    init: boolean;
+    constructor(el: ElementRef, gridster: GridsterComponent, renderer: Renderer2, zone: NgZone);
+    ngOnInit(): void;
+    updateOptions(): void;
+    ngOnDestroy(): void;
+    setSize(): void;
+    updateItemSize(): void;
+    itemChanged(): void;
+    checkItemChanges(newValue: GridsterItem, oldValue: GridsterItem): void;
+    canBeDragged(): boolean;
+    canBeResized(): boolean;
+}

package/gridster/lib/gridsterItem.interface.d.ts

@@ -0,0 +1,21 @@
+import { GridsterItemComponentInterface } from './gridsterItemComponent.interface';
+export interface GridsterItem {
+    x: number;
+    y: number;
+    rows: number;
+    cols: number;
+    initCallback?: (item: GridsterItem, itemComponent: GridsterItemComponentInterface) => void;
+    dragEnabled?: boolean;
+    resizeEnabled?: boolean;
+    compactEnabled?: boolean;
+    maxItemRows?: number;
+    minItemRows?: number;
+    maxItemCols?: number;
+    minItemCols?: number;
+    minItemArea?: number;
+    maxItemArea?: number;
+    [propName: string]: any;
+    curRowHeight?: number;
+    widgetHeight?: number;
+    widgetInfo?: any;
+}

package/gridster/lib/gridsterItemComponent.interface.d.ts

@@ -0,0 +1,25 @@
+import { GridsterItem } from './gridsterItem.interface';
+import { GridsterDraggable } from './gridsterDraggable.service';
+import { Renderer2 } from '@angular/core';
+import { GridsterResizable } from './gridsterResizable.service';
+import { GridsterComponentInterface } from './gridster.interface';
+export declare abstract class GridsterItemComponentInterface {
+    item: GridsterItem;
+    $item: GridsterItem;
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+    drag: GridsterDraggable;
+    resize: GridsterResizable;
+    notPlaced: boolean;
+    updateOptions: () => void;
+    itemChanged: () => void;
+    setSize: () => void;
+    checkItemChanges: (newValue: GridsterItem, oldValue: GridsterItem) => void;
+    canBeDragged: () => boolean;
+    canBeResized: () => boolean;
+    el: any;
+    gridster: GridsterComponentInterface;
+    renderer: Renderer2;
+}

package/gridster/lib/gridsterPreview.component.d.ts

@@ -0,0 +1,10 @@
+import { ElementRef, OnDestroy, Renderer2 } from '@angular/core';
+import { GridsterComponent } from './gridster.component';
+export declare class GridsterPreviewComponent implements OnDestroy {
+    renderer: Renderer2;
+    el: any;
+    gridster: GridsterComponent;
+    constructor(el: ElementRef, gridster: GridsterComponent, renderer: Renderer2);
+    ngOnDestroy(): void;
+    previewStyle(drag?: boolean): void;
+}

package/gridster/lib/gridsterPush.service.d.ts

@@ -0,0 +1,33 @@
+import { GridsterItemComponentInterface } from './gridsterItemComponent.interface';
+export declare class GridsterPush {
+    fromSouth: string;
+    fromNorth: string;
+    fromEast: string;
+    fromWest: string;
+    private pushedItems;
+    private pushedItemsTemp;
+    private pushedItemsTempPath;
+    private pushedItemsPath;
+    private gridsterItem;
+    private gridster;
+    private pushedItemsOrder;
+    private tryPattern;
+    constructor(gridsterItem: GridsterItemComponentInterface);
+    destroy(): void;
+    pushItems(direction: string, disable?: boolean): boolean;
+    restoreTempItems(): void;
+    restoreItems(): void;
+    setPushedItems(): void;
+    checkPushBack(): void;
+    private push;
+    private trySouth;
+    private tryNorth;
+    private tryEast;
+    private tryWest;
+    private addToTempPushed;
+    private removeFromTempPushed;
+    private addToPushed;
+    private removeFromPushed;
+    private removeFromPushedItem;
+    private checkPushedItem;
+}

package/gridster/lib/gridsterPushResize.service.d.ts

@@ -0,0 +1,26 @@
+import { GridsterItemComponentInterface } from './gridsterItemComponent.interface';
+export declare class GridsterPushResize {
+    fromSouth: string;
+    fromNorth: string;
+    fromEast: string;
+    fromWest: string;
+    private pushedItems;
+    private pushedItemsPath;
+    private gridsterItem;
+    private gridster;
+    private tryPattern;
+    constructor(gridsterItem: GridsterItemComponentInterface);
+    destroy(): void;
+    pushItems(direction: string): boolean;
+    restoreItems(): void;
+    setPushedItems(): void;
+    checkPushBack(): void;
+    private push;
+    private trySouth;
+    private tryNorth;
+    private tryEast;
+    private tryWest;
+    private addToPushed;
+    private removeFromPushed;
+    private checkPushedItem;
+}

package/gridster/lib/gridsterRenderer.service.d.ts

@@ -0,0 +1,38 @@
+import { Renderer2 } from '@angular/core';
+import { GridsterComponentInterface } from './gridster.interface';
+import { GridsterItem } from './gridsterItem.interface';
+export declare class GridsterRenderer {
+    private gridster;
+    constructor(gridster: GridsterComponentInterface);
+    destroy(): void;
+    updateItem(el: any, item: GridsterItem, renderer: Renderer2): void;
+    updateGridster(): void;
+    getGridColumnStyle(i: number): {
+        width: string;
+        height: string;
+        constructor: Function;
+        toString(): string;
+        toLocaleString(): string;
+        valueOf(): Object;
+        hasOwnProperty(v: string | number | symbol): boolean;
+        isPrototypeOf(v: Object): boolean;
+        propertyIsEnumerable(v: string | number | symbol): boolean;
+    };
+    getGridRowStyle(i: number): {
+        width: string;
+        height: string;
+        constructor: Function;
+        toString(): string;
+        toLocaleString(): string;
+        valueOf(): Object;
+        hasOwnProperty(v: string | number | symbol): boolean;
+        isPrototypeOf(v: Object): boolean;
+        propertyIsEnumerable(v: string | number | symbol): boolean;
+    };
+    getLeftPosition(d: number): Object;
+    getTopPosition(d: number): Object;
+    clearCellPosition(renderer: Renderer2, el: any): void;
+    setCellPosition(renderer: Renderer2, el: any, x: number, y: number): void;
+    getLeftMargin(): number;
+    getTopMargin(): number;
+}