angular-gridster2/index.d.ts

Angular gridster 2

import * as i0 from '@angular/core';
import { NgZone, Renderer2, ChangeDetectorRef, OnInit, OnChanges, OnDestroy, EventEmitter, ElementRef, SimpleChanges } from '@angular/core';
import { Subject } from 'rxjs';

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;
    private iteration;
    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;
}

declare class GridsterSwap {
    private swapedItem;
    private gridsterItem;
    private gridster;
    constructor(gridsterItem: GridsterItemComponentInterface);
    destroy(): void;
    swapItems(): void;
    checkSwapBack(): void;
    restoreSwapItem(): void;
    setSwapItem(): void;
    checkSwap(pushedBy: GridsterItemComponentInterface): void;
}

declare class GridsterDraggable {
    private zone;
    gridsterItem: GridsterItemComponentInterface;
    gridster: GridsterComponentInterface;
    lastMouse: {
        clientX: number;
        clientY: number;
    };
    offsetLeft: number;
    offsetTop: number;
    margin: number;
    outerMarginTop: number | null;
    outerMarginRight: number | null;
    outerMarginBottom: number | null;
    outerMarginLeft: number | null;
    diffTop: number;
    diffLeft: number;
    originalClientX: number;
    originalClientY: number;
    top: number;
    left: number;
    height: number;
    width: number;
    positionX: number;
    positionY: number;
    positionXBackup: number;
    positionYBackup: number;
    enabled: boolean;
    mousemove: () => void;
    mouseup: () => void;
    mouseleave: () => void;
    cancelOnBlur: () => void;
    touchmove: () => void;
    touchend: () => void;
    touchcancel: () => void;
    mousedown: () => void;
    touchstart: () => void;
    push: GridsterPush;
    swap: GridsterSwap;
    path: Array<{
        x: number;
        y: number;
    }>;
    collision: GridsterItemComponentInterface | boolean;
    constructor(gridsterItem: GridsterItemComponentInterface, gridster: GridsterComponentInterface, zone: NgZone);
    destroy(): void;
    dragStart(e: MouseEvent): void;
    dragMove: (e: MouseEvent) => void;
    calculateItemPositionFromMousePosition: (e: MouseEvent) => void;
    calculateItemPositionWithScale(e: MouseEvent, scale: number): void;
    calculateItemPositionWithoutScale(e: MouseEvent): void;
    dragStop: (e: MouseEvent) => void;
    cancelDrag: () => void;
    makeDrag: () => void;
    calculateItemPosition(): void;
    toggle(): void;
    dragStartDelay: (e: MouseEvent) => void;
    /**
     * Returns the list of directions for given mouse event
     * @param e Mouse event
     * */
    private getDirections;
}

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;
}

interface GridsterResizeEventType {
    north: boolean;
    south: boolean;
    west: boolean;
    east: boolean;
}

declare class GridsterResizable {
    private zone;
    gridsterItem: GridsterItemComponentInterface;
    gridster: GridsterComponentInterface;
    lastMouse: {
        clientX: number;
        clientY: number;
    };
    itemBackup: {
        x: number;
        y: number;
        cols: number;
        rows: number;
    };
    resizeEventScrollType: GridsterResizeEventType;
    /**
     * The direction function may reference any of the `GridsterResizable` class methods, that are
     * responsible for gridster resize when the `dragmove` event is being handled. E.g. it may reference
     * the `handleNorth` method when the north handle is pressed and moved by a mouse.
     */
    private directionFunction;
    resizeEnabled: boolean;
    resizableHandles?: {
        s: boolean;
        e: boolean;
        n: boolean;
        w: boolean;
        se: boolean;
        ne: boolean;
        sw: boolean;
        nw: boolean;
    };
    mousemove: () => void;
    mouseup: () => void;
    mouseleave: () => void;
    cancelOnBlur: () => void;
    touchmove: () => void;
    touchend: () => void;
    touchcancel: () => void;
    push: GridsterPush;
    pushResize: GridsterPushResize;
    minHeight: number;
    minWidth: number;
    offsetTop: number;
    offsetLeft: number;
    diffTop: number;
    diffLeft: number;
    diffRight: number;
    diffBottom: number;
    margin: number;
    outerMarginTop: number | null;
    outerMarginRight: number | null;
    outerMarginBottom: number | null;
    outerMarginLeft: number | null;
    originalClientX: number;
    originalClientY: number;
    top: number;
    left: number;
    bottom: number;
    right: number;
    width: number;
    height: number;
    hasRatio: boolean;
    constructor(gridsterItem: GridsterItemComponentInterface, gridster: GridsterComponentInterface, zone: NgZone);
    destroy(): void;
    dragStart(e: MouseEvent): void;
    dragMove: (e: MouseEvent) => void;
    dragStop: (e: MouseEvent) => void;
    cancelResize: () => void;
    makeResize: () => void;
    private check;
    private getNewNorthPosition;
    private handleNorth;
    private getNewWestPosition;
    private handleWest;
    private getNewSouthPosition;
    private handleSouth;
    private getNewEastPosition;
    private handleEast;
    private handleNorthWest;
    private handleNorthEast;
    private handleSouthWest;
    private handleSouthEast;
    private makeItemBackup;
    private resetItem;
    toggle(): void;
    dragStartDelay(e: MouseEvent | TouchEvent): void;
    setItemTop(top: number): void;
    setItemLeft(left: number): void;
    setItemHeight(height: number): void;
    setItemWidth(width: number): void;
    /**
     * Enforces the aspect ratio by recalculating grid positions based on current pixel dimensions
     */
    private enforceAspectRatio;
}

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;
    getResizableHandles: () => {
        s: boolean;
        e: boolean;
        n: boolean;
        w: boolean;
        se: boolean;
        ne: boolean;
        sw: boolean;
        nw: boolean;
    };
    bringToFront: (offset: number) => void;
    sendToBack: (v: number) => void;
    el: HTMLElement;
    gridster: GridsterComponentInterface;
    renderer: Renderer2;
}
interface GridsterItem {
    x: number;
    y: number;
    rows: number;
    cols: number;
    layerIndex?: number;
    initCallback?: (item: GridsterItem, itemComponent: GridsterItemComponentInterface) => void;
    dragEnabled?: boolean;
    resizeEnabled?: boolean;
    resizableHandles?: {
        s?: boolean;
        e?: boolean;
        n?: boolean;
        w?: boolean;
        se?: boolean;
        ne?: boolean;
        sw?: boolean;
        nw?: boolean;
    };
    compactEnabled?: boolean;
    itemAspectRatio?: number;
    maxItemRows?: number;
    minItemRows?: number;
    maxItemCols?: number;
    minItemCols?: number;
    minItemArea?: number;
    maxItemArea?: number;
    [propName: string]: any;
}

type gridTypes = 'fit' | 'scrollVertical' | 'scrollHorizontal' | 'fixed' | 'verticalFixed' | 'horizontalFixed';
type displayGrids = 'always' | 'onDrag&Resize' | 'none';
type compactTypes = 'none' | 'compactUp' | 'compactLeft' | 'compactUp&Left' | 'compactLeft&Up' | 'compactRight' | 'compactUp&Right' | 'compactRight&Up' | 'compactDown' | 'compactDown&Left' | 'compactLeft&Down' | 'compactDown&Right' | 'compactRight&Down' | 'compactGrid';
declare enum GridType {
    Fit = "fit",
    ScrollVertical = "scrollVertical",
    ScrollHorizontal = "scrollHorizontal",
    Fixed = "fixed",
    VerticalFixed = "verticalFixed",
    HorizontalFixed = "horizontalFixed"
}
declare enum DisplayGrid {
    Always = "always",
    OnDragAndResize = "onDrag&Resize",
    None = "none"
}
declare enum CompactType {
    None = "none",
    CompactUp = "compactUp",
    CompactLeft = "compactLeft",
    CompactUpAndLeft = "compactUp&Left",
    CompactLeftAndUp = "compactLeft&Up",
    CompactRight = "compactRight",
    CompactUpAndRight = "compactUp&Right",
    CompactRightAndUp = "compactRight&Up",
    CompactDown = "compactDown",
    CompactDownAndLeft = "compactDown&Left",
    CompactLeftAndDown = "compactLeft&Down",
    CompactDownAndRight = "compactDown&Right",
    CompactRightAndDown = "compactRight&Down",
    CompactGrid = "compactGrid"
}
declare enum DirTypes {
    LTR = "ltr",
    RTL = "rtl"
}
type dirTypes = 'ltr' | 'rtl';
interface GridsterConfig {
    gridType?: gridTypes;
    scale?: number;
    fixedColWidth?: number;
    fixedRowHeight?: number;
    keepFixedHeightInMobile?: boolean;
    keepFixedWidthInMobile?: boolean;
    setGridSize?: boolean;
    compactType?: compactTypes;
    mobileBreakpoint?: number;
    allowMultiLayer?: boolean;
    defaultLayerIndex?: number;
    maxLayerIndex?: number;
    baseLayerIndex?: number;
    minCols?: number;
    maxCols?: number;
    minRows?: number;
    maxRows?: number;
    defaultItemCols?: number;
    defaultItemRows?: number;
    itemAspectRatio?: number;
    maxItemCols?: number;
    maxItemRows?: number;
    minItemCols?: number;
    minItemRows?: number;
    minItemArea?: number;
    maxItemArea?: number;
    addEmptyRowsCount?: number;
    rowHeightRatio?: 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$1;
    resizable?: Resizable$1;
    swap?: boolean;
    swapWhileDragging?: boolean;
    pushItems?: boolean;
    disablePushOnDrag?: boolean;
    disablePushOnResize?: boolean;
    disableAutoPositionOnConflict?: boolean;
    pushDirections?: PushDirections$1;
    pushResizeItems?: boolean;
    displayGrid?: displayGrids;
    disableWindowResize?: boolean;
    disableWarnings?: boolean;
    scrollToNewItems?: boolean;
    disableScrollHorizontal?: boolean;
    disableScrollVertical?: boolean;
    enableBoundaryControl?: boolean;
    enableEmptyCellClick?: boolean;
    enableEmptyCellContextMenu?: boolean;
    enableEmptyCellDrop?: boolean;
    enableEmptyCellDrag?: boolean;
    enableOccupiedCellDrop?: boolean;
    emptyCellClickCallback?: (event: MouseEvent, item: GridsterItem) => void;
    emptyCellContextMenuCallback?: (event: MouseEvent, item: GridsterItem) => void;
    emptyCellDropCallback?: (event: DragEvent, item: GridsterItem) => void;
    emptyCellDragCallback?: (event: MouseEvent, item: GridsterItem) => void;
    emptyCellDragMaxCols?: number;
    emptyCellDragMaxRows?: number;
    ignoreMarginInRow?: boolean;
    dirType?: dirTypes;
    api?: {
        resize?: () => void;
        optionsChanged?: () => void;
        getNextPossiblePosition?: (newItem: GridsterItem) => boolean;
        getFirstPossiblePosition?: (item: GridsterItem) => GridsterItem;
        getLastPossiblePosition?: (item: GridsterItem) => GridsterItem;
        getItemComponent?: (item: GridsterItem) => GridsterItemComponentInterface | undefined;
    };
    [propName: string]: any;
}
interface DragBase$1 {
    enabled?: boolean;
    stop?: (item: GridsterItem, itemComponent: GridsterItemComponentInterface, event: MouseEvent) => Promise<any> | void;
    start?: (item: GridsterItem, itemComponent: GridsterItemComponentInterface, event: MouseEvent) => void;
    delayStart?: number;
}
interface Draggable$1 extends DragBase$1 {
    ignoreContentClass?: string;
    ignoreContent?: boolean;
    dragHandleClass?: string;
    dropOverItems?: boolean;
    dropOverItemsCallback?: (source: GridsterItem, target: GridsterItem, grid?: GridsterComponentInterface) => void;
}
interface Resizable$1 extends DragBase$1 {
    handles?: {
        s: boolean;
        e: boolean;
        n: boolean;
        w: boolean;
        se: boolean;
        ne: boolean;
        sw: boolean;
        nw: boolean;
    };
}
interface PushDirections$1 {
    north: boolean;
    east: boolean;
    south: boolean;
    west: boolean;
}

interface GridsterConfigS {
    gridType: gridTypes;
    scale?: number;
    fixedColWidth: number;
    fixedRowHeight: number;
    keepFixedHeightInMobile: boolean;
    keepFixedWidthInMobile: boolean;
    setGridSize: boolean;
    compactType: compactTypes;
    mobileBreakpoint: number;
    useBodyForBreakpoint: boolean;
    allowMultiLayer: boolean;
    defaultLayerIndex: number;
    maxLayerIndex: number;
    baseLayerIndex: number;
    minCols: number;
    maxCols: number;
    minRows: number;
    maxRows: number;
    defaultItemCols: number;
    defaultItemRows: number;
    itemAspectRatio: number;
    maxItemCols: number;
    maxItemRows: number;
    minItemCols: number;
    minItemRows: number;
    minItemArea: number;
    maxItemArea: number;
    addEmptyRowsCount: number;
    rowHeightRatio: 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;
    swapWhileDragging: boolean;
    pushItems: boolean;
    disablePushOnDrag: boolean;
    disablePushOnResize: boolean;
    disableAutoPositionOnConflict: boolean;
    pushDirections: PushDirections;
    pushResizeItems: boolean;
    displayGrid: displayGrids;
    disableWindowResize: boolean;
    disableWarnings: boolean;
    scrollToNewItems: boolean;
    disableScrollHorizontal?: boolean;
    disableScrollVertical?: boolean;
    enableBoundaryControl?: boolean;
    enableEmptyCellClick: boolean;
    enableEmptyCellContextMenu: boolean;
    enableEmptyCellDrop: boolean;
    enableEmptyCellDrag: boolean;
    enableOccupiedCellDrop: boolean;
    emptyCellDragMaxCols: number;
    emptyCellDragMaxRows: number;
    ignoreMarginInRow: boolean;
    dirType: dirTypes;
    api: {
        resize: () => void;
        optionsChanged: () => void;
        getNextPossiblePosition: (newItem: GridsterItem) => boolean;
        getFirstPossiblePosition: (item: GridsterItem) => GridsterItem;
        getLastPossiblePosition: (item: GridsterItem) => GridsterItem;
        getItemComponent: (item: GridsterItem) => GridsterItemComponentInterface | undefined;
    };
    [propName: string]: any;
}
interface DragBase {
    enabled: boolean;
    delayStart: number;
    [propName: string]: any;
}
interface Draggable extends DragBase {
    ignoreContentClass: string;
    ignoreContent: boolean;
    dragHandleClass: string;
    dropOverItems: boolean;
    dropOverItemsCallback: (source: GridsterItem, target: GridsterItem, grid?: GridsterComponentInterface) => void;
}
interface Resizable extends DragBase {
    handles: {
        s: boolean;
        e: boolean;
        n: boolean;
        w: boolean;
        se: boolean;
        ne: boolean;
        sw: boolean;
        nw: boolean;
    };
}
interface PushDirections {
    north: boolean;
    east: boolean;
    south: boolean;
    west: boolean;
}

declare class GridsterEmptyCell {
    private gridster;
    initialItem: GridsterItem | null;
    removeEmptyCellClickListenerFn: (() => void) | null;
    removeEmptyCellTouchendListenerFn: (() => void) | null;
    removeEmptyCellContextMenuListenerFn: (() => void) | null;
    removeEmptyCellDropListenerFn: (() => void) | null;
    removeEmptyCellMousedownListenerFn: (() => void) | null;
    removeEmptyCellTouchstartListenerFn: (() => void) | null;
    removeWindowMousemoveListenerFn: () => void;
    removeWindowTouchmoveListenerFn: () => void;
    removeWindowMouseupListenerFn: () => void;
    removeWindowTouchendListenerFn: () => void;
    removeEmptyCellDragoverListenerFn: (() => void) | null;
    removeDocumentDragendListenerFn: (() => void) | null;
    constructor(gridster: GridsterComponentInterface);
    destroy(): void;
    updateOptions(): void;
    emptyCellClickCb: (e: MouseEvent) => void;
    emptyCellContextMenuCb: (e: MouseEvent) => void;
    emptyCellDragDrop: (e: DragEvent) => void;
    emptyCellDragOver: (e: DragEvent) => void;
    emptyCellMouseDown: (e: MouseEvent) => void;
    emptyCellMouseMove: (e: MouseEvent) => void;
    emptyCellMouseUp: (e: MouseEvent) => void;
    getPixelsX(e: MouseEvent, rect: ClientRect): number;
    getPixelsY(e: MouseEvent, rect: ClientRect): number;
    getValidItemFromEvent(e: MouseEvent, oldItem?: GridsterItem | null): GridsterItem | undefined;
}

declare class GridsterCompact {
    private gridster;
    constructor(gridster: GridsterComponentInterface);
    destroy(): void;
    checkCompact(): void;
    checkCompactItem(item: GridsterItem): void;
    private checkCompactMovement;
    private moveTillCollision;
    private checkCompactGrid;
    private moveToGridPosition;
}

interface CommonGridStyle {
    [key: string]: string;
}

declare class GridsterRenderer {
    private gridster;
    /**
     * Caches the last grid column styles.
     * This improves the grid responsiveness by caching and reusing the last style object instead of creating a new one.
     */
    private lastGridColumnStyles;
    /**
     * Caches the last grid column styles.
     * This improves the grid responsiveness by caching and reusing the last style object instead of creating a new one.
     */
    private lastGridRowStyles;
    constructor(gridster: GridsterComponentInterface);
    destroy(): void;
    updateItem(el: Element, item: GridsterItem, renderer: Renderer2): void;
    updateGridster(): void;
    getGridColumnStyle(i: number): CommonGridStyle;
    getGridRowStyle(i: number): CommonGridStyle;
    getLeftPosition(d: number): {
        left: string;
    } | {
        transform: string;
    };
    getTopPosition(d: number): {
        top: string;
    } | {
        transform: string;
    };
    clearCellPosition(renderer: Renderer2, el: Element): void;
    setCellPosition(renderer: Renderer2, el: Element, x: number, y: number): void;
    getLeftMargin(): number;
    getTopMargin(): number;
}

declare abstract class GridsterComponentInterface {
    $options: GridsterConfigS;
    grid: GridsterItemComponentInterface[];
    checkCollision: (item: GridsterItem, checkRatio?: boolean) => GridsterItemComponentInterface | boolean;
    checkCollisionForSwaping: (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) => GridsterItemComponentInterface[];
    checkGridCollision: (item: GridsterItem) => boolean;
    checkCollisionTwoItems: (item: GridsterItem, item2: GridsterItem) => boolean;
    getItemComponent: (item: GridsterItem) => GridsterItemComponentInterface | undefined;
    el: HTMLElement;
    renderer: Renderer2;
    gridRenderer: GridsterRenderer;
    cdRef: ChangeDetectorRef;
    options: GridsterConfig;
    calculateLayout$: Subject<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>;
}

declare class GridsterComponent implements OnInit, OnChanges, OnDestroy, GridsterComponentInterface {
    renderer: Renderer2;
    cdRef: ChangeDetectorRef;
    zone: NgZone;
    options: GridsterConfig;
    movingItem: GridsterItem | null;
    el: HTMLElement;
    $options: GridsterConfigS;
    mobile: boolean;
    curWidth: number;
    curHeight: number;
    grid: GridsterItemComponentInterface[];
    columns: number;
    rows: number;
    curColWidth: number;
    curRowHeight: number;
    gridColumns: never[];
    gridRows: never[];
    windowResize: (() => void) | null;
    dragInProgress: boolean;
    emptyCell: GridsterEmptyCell;
    compact: GridsterCompact;
    gridRenderer: GridsterRenderer;
    previewStyle$: EventEmitter<GridsterItem | null>;
    calculateLayout$: Subject<void>;
    private resize$;
    private destroy$;
    constructor(el: ElementRef, renderer: Renderer2, cdRef: ChangeDetectorRef, zone: NgZone);
    static checkCollisionTwoItemsForSwaping(item: GridsterItem, item2: GridsterItem): boolean;
    checkCollisionTwoItems(item: GridsterItem, item2: GridsterItem): boolean;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    private resize;
    setOptions(): void;
    optionsChanged: () => void;
    ngOnDestroy(): void;
    onResize: () => void;
    checkIfToResize(): boolean;
    checkIfMobile(): boolean;
    setGridSize(): void;
    setGridDimensions(): void;
    private calculateLayout;
    updateGrid(): void;
    addItem(itemComponent: GridsterItemComponentInterface): void;
    removeItem(itemComponent: GridsterItemComponentInterface): void;
    checkCollision(item: GridsterItem, checkRatio?: boolean): GridsterItemComponentInterface | boolean;
    checkGridCollision(item: GridsterItem, checkRatio?: boolean): 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: (x: number) => number, noLimit?: boolean): number;
    pixelsToPositionY(y: number, roundingMethod: (x: number) => number, noLimit?: boolean): number;
    positionXToPixels(x: number): number;
    positionYToPixels(y: number): number;
    getItemComponent(item: GridsterItem): GridsterItemComponentInterface | undefined;
    checkCollisionForSwaping(item: GridsterItem): GridsterItemComponentInterface | boolean;
    findItemWithItemForSwapping(item: GridsterItem): GridsterItemComponentInterface | boolean;
    previewStyle(drag?: boolean): void;
    private static getNewArrayLength;
    static ɵfac: i0.ɵɵFactoryDeclaration<GridsterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GridsterComponent, "gridster", never, { "options": { "alias": "options"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class GridsterItemComponent implements OnInit, OnDestroy, OnChanges, GridsterItemComponentInterface {
    renderer: Renderer2;
    private zone;
    item: GridsterItem;
    itemInit: EventEmitter<{
        item: GridsterItem;
        itemComponent: GridsterItemComponentInterface;
    }>;
    itemChange: EventEmitter<{
        item: GridsterItem;
        itemComponent: GridsterItemComponentInterface;
    }>;
    itemResize: EventEmitter<{
        item: GridsterItem;
        itemComponent: GridsterItemComponentInterface;
    }>;
    $item: GridsterItem;
    el: HTMLElement;
    gridster: GridsterComponent;
    top: number;
    left: number;
    width: number;
    height: number;
    drag: GridsterDraggable;
    resize: GridsterResizable;
    notPlaced: boolean;
    init: boolean;
    get zIndex(): number;
    constructor(el: ElementRef, gridster: GridsterComponent, renderer: Renderer2, zone: NgZone);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    updateOptions(): void;
    ngOnDestroy(): void;
    setSize(): void;
    updateItemSize(): void;
    itemChanged(): void;
    checkItemChanges(newValue: GridsterItem, oldValue: GridsterItem): void;
    canBeDragged(): boolean;
    canBeResized(): boolean;
    getResizableHandles(): {
        s: boolean;
        e: boolean;
        n: boolean;
        w: boolean;
        se: boolean;
        ne: boolean;
        sw: boolean;
        nw: boolean;
    };
    bringToFront(offset: number): void;
    sendToBack(offset: number): void;
    private getLayerIndex;
    static ɵfac: i0.ɵɵFactoryDeclaration<GridsterItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GridsterItemComponent, "gridster-item", never, { "item": { "alias": "item"; "required": false; }; }, { "itemInit": "itemInit"; "itemChange": "itemChange"; "itemResize": "itemResize"; }, never, ["*"], true, never>;
}

declare const GridsterConfigService: GridsterConfig;

declare class GridsterModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<GridsterModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<GridsterModule, never, [typeof GridsterComponent, typeof GridsterItemComponent], [typeof GridsterComponent, typeof GridsterItemComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<GridsterModule>;
}

export { CompactType, DirTypes, DisplayGrid, GridType, GridsterComponent, GridsterComponentInterface, GridsterConfigService, GridsterItemComponent, GridsterItemComponentInterface, GridsterModule, GridsterPush, GridsterPushResize, GridsterSwap };
export type { Draggable$1 as Draggable, GridsterConfig, GridsterItem, PushDirections$1 as PushDirections, Resizable$1 as Resizable };