realreport/dist/realreport.d.ts

RealReport Runtime Viewer

/// <reference types="pdfkit" />
/** 
* RealReport v1.11.3
* commit 8ce7c84

* {@link https://real-report.com}
* Copyright (C) 2013-2025 WooriTech Inc.
* All Rights Reserved.
*/

import { Cvfo, Style } from 'exceljs';

/** 
* RealReport Core v1.11.3
* Copyright (C) 2013-2025 WooriTech Inc.
* All Rights Reserved.
* commit 645ea5b84a0ca9591145ea337113c4aeade413ed
*/


type ConfigObject$1 = {
    [key: string]: any;
};
/** @internal */
declare abstract class Base$1 {
    private $_hash;
    private $_disposed;
    private $_disposing;
    constructor();
    dispose(): null;
    protected _doDispose(): void;
    get disposing(): boolean;
    get hash(): number;
    get shash(): string;
    isMe(hash: number): boolean;
    private $_getters;
    /**
     * true를 리턴하면 assign()이 호출되지 않는다.
     */
    protected doAssignSimple(source: any): boolean;
    assignFrom(source: any): void;
    extend(source: ConfigObject$1): void;
    toProxy(): ConfigObject$1;
    assignProps(target: object, props: string[], all?: boolean): object;
    toString(): string;
}

/** @internal */
declare class DatetimeReader {
    static readonly Formats: string[];
    static readonly Default: DatetimeReader;
    static initialize(): void;
    private _format;
    private _type;
    private _parser;
    constructor(format: string);
    /** format */
    get format(): string;
    set format(value: string);
    /** amText */
    get amText(): string;
    set amText(value: string);
    /** pmText */
    get pmText(): string;
    set pmText(value: string);
    /** baseYear */
    get baseYear(): number;
    set baseYear(value: number);
    toDate(value: string): Date;
    private parse;
}

interface IEventAware {
    addListener(listener: object): IEventAware;
    removeListener(listener: object): IEventAware;
}
/** @internal */
declare class EventAware$1 extends Base$1 implements IEventAware {
    private _listeners;
    constructor();
    protected _doDispose(): void;
    get listenerCount(): number;
    addListener(listener: object): IEventAware;
    removeListener(listener: object): IEventAware;
    isListener(listener: any): boolean;
    clearListener(): void;
    fireEvent(event: string, ...args: any): void;
    fireConfirmEvent(event: string, ...args: any): boolean;
    fireMessageEvent(event: string, ...args: any): string;
    fireObjectEvent(event: string, ...args: any): any;
}

type EditCommandCallback<T extends EditCommand$1 = EditCommand$1> = (cmd: T) => void;
/**
 * Edit command base.
 * 편집 행위 외에 다른 로직이 포함되지 않도록 한다.
 */
declare abstract class EditCommand$1 extends Base$1 {
    static createGroup(...commands: EditCommand$1[]): EditCommandGroup;
    constructor();
    protected _doDispose(): void;
    abstract get source(): any;
    error: any;
    get page(): any;
    abstract undo(): void;
    abstract redo(redoing: boolean): any;
    run(): any;
}
/**
 * Edit command group base.
 * 하나 이상의 command를 동시에 실행하거나 undo한다.
 */
declare class EditCommandGroup extends EditCommand$1 {
    private _commands;
    constructor(commands: EditCommand$1[]);
    protected _doDispose(): void;
    get commands(): EditCommand$1[];
    undo(): void;
    redo(redoing: boolean): any;
    get source(): any;
    get page(): any;
}
/**
 * Edit command stack owner spec.
 */
interface IEditCommandStackOwner {
    editCommandStackChanged(stack: EditCommandStack$1, cmd: EditCommand$1, undoable: boolean, redoable: boolean): void;
    editCommandStackDirtyChanged(stack: EditCommandStack$1): void;
    editCommandError(command: EditCommand$1): void;
}
/**
 * Edit command stack.
 * 커맨드는 반드시 이 객체를 통해서 실행되거나 undo 되어야 한다.
 */
declare class EditCommandStack$1 extends EventAware$1 {
    owner: IEditCommandStackOwner;
    private _commands;
    private _current;
    private _closed;
    private _undoing;
    private _redoing;
    constructor(owner: IEditCommandStackOwner);
    protected _doDispose(): void;
    /** length */
    get length(): number;
    /** current */
    get current(): number;
    /** empty */
    get empty(): boolean;
    /** canUndo */
    get canUndo(): boolean;
    /** canRedo */
    get canRedo(): boolean;
    /** undoing */
    get undoing(): boolean;
    /** redoing */
    get redoing(): boolean;
    /** dirty */
    get dirty(): boolean;
    get(index: number): EditCommand$1;
    peek(): EditCommand$1;
    undo(): boolean;
    redo(redoing?: boolean): boolean;
    execute(command: EditCommand$1): boolean;
    flush(): void;
    /**
     * 현 위치를 marking한다. dirty는 마지막 marking 시점과 다른 경우 true가 된다.
     */
    close(): void;
    getHistory(all?: boolean): EditCommand$1[];
    protected _changed(oldCurrent: number, cmd: EditCommand$1): void;
    private $_shrink;
}

/**@internal */
declare abstract class ExpressionRuntime$1 extends Base$1 {
    constructor();
    isIdentifier(token: string, isValue?: boolean): number;
    evaluateIdentifier(idKey: number): void;
    evaluateIndexerI(idKey: number, index: number): any;
    evaluateIndexerS(idKey: number, index: string, capital: boolean): any;
    evaluateFunc(idKey: number, param: string): any;
}
/**@internal */
declare abstract class ExpressionNode$1 {
    constructor();
    get value(): any;
    get asLiteral(): any;
    prepareValue(): void;
    getLiteral(): ExpressionNode$1;
    isIdentifier(value: any): boolean;
    abstract evaluate(runtime: ExpressionRuntime$1): any;
    toString(): string;
}

interface IExcelDataInfo {
    /**
     * 컬럼들의 이름이 표시되는 행 번호. 행은 1부터 시작.
     */
    headerRow?: number;
    /**
     * 데이터가 시작되는 행 번호. 지정하지 않으면 headerRow + 1.
     */
    startRow?: number;
    /**
     * 최대 행 수. 지정하지 않으면 마지막 데이터 행까지.
     */
    rowCount?: number;
    /**
     * 데이터가 시작되는 col. 지정하지 않으면 "A".
     */
    startCol?: string;
    /**
     * 마지막 행 여부 검사 기준 컬럼. 지정하지 않으면 Start Col. 이 행 이전까지 데이터 행.
     */
    endRowCol?: string;
    /**
     * 마지막 행 검사 기준 값. 지정하지 않으면 빈 셀.
     */
    endCheckValue?: any;
    /**
     * headerRow가 존재하는 경우 header cell의 이름을 field와 mapping하는 데 사용.
     */
    useHeaderNames?: boolean;
}
interface IExcelDataReader {
    readDataRows(buffer: ArrayBuffer, fields: IBandDataField[], info: IExcelDataInfo): Promise<any[]>;
}

/**@internal */
declare class FieldValueRuntime extends ExpressionRuntime$1 {
    private _data;
    private _fieldMap;
    private _row;
    prepare(data: BandData): FieldValueRuntime;
    setRow(row: number): FieldValueRuntime;
    isIdentifier(token: string): number;
    evaluateIdentifier(idKey: number): any;
    evaluateIndexerS(idKey: number, index: string, capitalized: boolean): any;
    evaluateFunc(idKey: number, param: string): any;
}

/** @internal */
interface VisualToolOwner$1 {
    findElementAt(x: number, y: number, hitTesting: boolean, blockLayer: boolean): VisualElement$1;
    findElementOf(dom: HTMLElement): VisualElement$1;
    getTableCell(dom: HTMLElement): HTMLTableCellElement;
}
/** @internal */
declare class VisualTool$1 extends Base$1 {
    private _owner;
    private _name;
    private _previous;
    private _dragTracker;
    private _clickX;
    private _clickY;
    private _mouseX;
    private _mouseY;
    private _mouseEventTarget;
    protected _lastTouch: number;
    constructor(owner: VisualToolOwner$1, name?: string);
    protected _doDispose(): void;
    /** owner */
    get owner(): VisualToolOwner$1;
    /** name */
    get name(): string;
    /** previous */
    get previous(): VisualTool$1;
    /** dragTracker */
    get dragTracker(): DragTracker$1;
    set dragTracker(value: DragTracker$1);
    /** dragging */
    get dragging(): boolean;
    /** mouseX */
    get mouseX(): number;
    /** mouseY */
    get mouseY(): number;
    get mouseEventTarget(): HTMLElement;
    findElementAt(x: number, y: number, hitTesting: boolean, blockLayer?: boolean): VisualElement$1;
    findElementOf(dom: HTMLElement): VisualElement$1;
    activate(previous: VisualTool$1): void;
    deactivate(): void;
    keyDown(event: KeyboardEvent): boolean;
    keyUp(event: KeyboardEvent): boolean;
    keyPress(event: KeyboardEvent): boolean;
    mouseDown(event: MouseEvent | TouchEvent): boolean;
    dragFrom(event: MouseEvent, tracker: DragTracker$1): void;
    dropFrom(event: MouseEvent, tracker: DragTracker$1): void;
    mouseMove(event: MouseEvent | TouchEvent): void;
    mouseUp(event: MouseEvent | TouchEvent): void;
    mouseEnter(event: MouseEvent): void;
    mouseLeave(event: MouseEvent): void;
    mouseOver(event: MouseEvent): void;
    mouseOutside(): void;
    mouseWheel(event: MouseEvent): boolean;
    contextMenu(event: MouseEvent): boolean;
    click(event: MouseEvent): void;
    dblclick(event: MouseEvent): void;
    setFocus(target?: HTMLElement): void;
    focusLeave(event: Event): void;
    dragStart(event: MouseEvent): void;
    dragEnd(event: MouseEvent): void;
    dragEnter(event: MouseEvent): void;
    dragOver(event: MouseEvent): void;
    dragLeave(event: MouseEvent): void;
    dragDrop(event: MouseEvent): void;
    protected isMouseEventTarget(elt: VisualElement$1): boolean;
    protected _doActivated(previous: VisualTool$1): void;
    protected _doDeactivated(): void;
    protected _doKeyDown(event: KeyboardEvent): boolean;
    protected _doKeyUp(event: KeyboardEvent): boolean;
    protected _doKeyPress(event: KeyboardEvent): boolean;
    /**
     * true 리턴하면 preventDefault 호출.
     */
    protected _doMouseDown(event: MouseEvent | TouchEvent): boolean;
    protected _doMouseMove(event: MouseEvent | TouchEvent): void;
    /** 그리드 밖에서도 호출된다. */
    protected _doMouseUp(event: MouseEvent | TouchEvent): void;
    protected _doMouseEnter(event: MouseEvent): void;
    protected _doMouseLeave(event: MouseEvent): void;
    protected _doMouseOver(event: MouseEvent): void;
    protected _doMouseOutside(): void;
    protected _doMouseWheel(event: MouseEvent): boolean;
    protected _doContextMenu(event: MouseEvent): boolean;
    /** 그리드 밖에서 마우스를 놓으면 호출되지 않는다. */
    protected _doClick(event: MouseEvent): void;
    protected _doDblClick(event: MouseEvent): void;
    protected _doSetFocus(target?: HTMLElement): void;
    protected _doFocusLeave(event: Event): void;
    protected _doDragStart(event: MouseEvent): void;
    protected _doDragEnd(event: MouseEvent): void;
    protected _doDragEnter(event: MouseEvent): void;
    protected _doDragOver(event: MouseEvent): void;
    protected _doDragLeave(event: MouseEvent): void;
    protected _doDragDrop(event: MouseEvent): void;
    protected _getDragTracker(request: EditRequest$1, x: number, y: number): DragTracker$1;
    protected _startDragTracker(x: number, y: number, shift: boolean, alt: boolean): void;
    protected _stopDragTracker(x: number, y: number, canceled: boolean): void;
    protected _doDragTrackerStarted(dragTracker: DragTracker$1): void;
    protected _doDragTrackerFinished(dragTracker: DragTracker$1, canceled: boolean): void;
    protected _findTableCell(source?: HTMLElement): HTMLTableCellElement;
    protected _doTouchStart(event: TouchEvent): void;
    protected _doTouchMove(event: TouchEvent): void;
    protected _doTouchEnd(evnet: TouchEvent): void;
    protected _doTouchCancel(evnet: TouchEvent): void;
}
/** @internal */
declare abstract class EditRequest$1 extends Base$1 {
    constructor();
    /** cursor */
    get cursor(): Cursor$1;
    /** source */
    get source(): any;
    /** selectable */
    get selectable(): boolean;
    /** dblClickable */
    get dblClickable(): boolean;
}
/** @internal */
declare class DragTracker$1 extends Base$1 {
    private _container;
    private _active;
    private _completed;
    private _dragging;
    private _startX;
    private _startY;
    private _currentX;
    private _currentY;
    constructor(container: VisualContainer$1);
    /** container */
    get container(): VisualContainer$1;
    /** active */
    get active(): boolean;
    /** dragging */
    get dragging(): boolean;
    /** startWhenCreated */
    get startWhenCreated(): boolean;
    /** completed */
    get completed(): boolean;
    /**
     * linkable proprerty.
     * 다른 그리드에서 진행 가능한 tracker.
     */
    get linkable(): boolean;
    get cursor(): string;
    activate(): void;
    deactivate(): void;
    start(eventTarget: HTMLElement, x: number, y: number, shift: boolean, alt: boolean): boolean;
    drag(eventTarget: HTMLElement, x: number, y: number, meta: boolean): boolean;
    cancel(): void;
    drop(eventTarget: HTMLElement, x: number, y: number): void;
    end(): void;
    getRequest(): EditRequest$1;
    getNextRequest(x: number, y: number): EditRequest$1;
    protected get startX(): number;
    protected get startY(): number;
    protected get currentX(): number;
    protected get currentY(): number;
    protected _showFeedback(x: number, y: number): void;
    protected _moveFeedback(x: number, y: number): void;
    protected _hideFeedback(): void;
    protected _doActivate(): void;
    protected _doDeactivate(): void;
    protected _doStart(eventTarget: HTMLElement, x: number, y: number, shfit: boolean, alt: boolean): boolean;
    protected _doDrag(eventTarget: HTMLElement, x: number, y: number, meta: boolean): boolean;
    protected _doCanceled(x: number, y: number): void;
    protected _canAccept(eventTarget: HTMLElement, x: number, y: number): boolean;
    protected _doCompleted(eventTarget: HTMLElement, x: number, y: number): void;
    protected _doEnded(): void;
}

interface IPoint {
    x: number;
    y: number;
}
interface IRect extends IPoint {
    width: number;
    height: number;
}
interface ISides {
    left: number;
    top: number;
    right: number;
    bottom: number;
}
/** @internal */
declare class Rectangle$1 implements IRect {
    x: number;
    y: number;
    width: number;
    height: number;
    static Empty: Readonly<Rectangle$1>;
    static Temp: Rectangle$1;
    static create(x: number, y: number, width: number, height: number): Rectangle$1;
    constructor(x?: number, y?: number, width?: number, height?: number);
    /** left */
    get left(): number;
    set left(value: number);
    /** right */
    get right(): number;
    set right(value: number);
    /** top */
    get top(): number;
    set top(value: number);
    /** bottom */
    get bottom(): number;
    set bottom(value: number);
    /** isEmpty */
    get isEmpty(): boolean;
    clone(): Rectangle$1;
    getInner(): Rectangle$1;
    equals(r: Rectangle$1): boolean;
    leftBy(delta: number): Rectangle$1;
    rightBy(delta: number): Rectangle$1;
    topBy(delta: number): Rectangle$1;
    bottomBy(delta: number): Rectangle$1;
    shrink(dx: number, dy: number): Rectangle$1;
    expand(dx: number, dy: number): Rectangle$1;
    contains(x: number, y: number): boolean;
    setEmpty(): Rectangle$1;
    move(x?: number, y?: number): Rectangle$1;
    set(x: number, y: number, width: number, height: number): Rectangle$1;
    setWidth(value: number): Rectangle$1;
    copy(r: Rectangle$1): Rectangle$1;
    copyHorz(r: Rectangle$1): Rectangle$1;
    copyVert(r: Rectangle$1): Rectangle$1;
    inflate(left?: number, top?: number, right?: number, bottom?: number): Rectangle$1;
    translate(dx: number, dy: number): Rectangle$1;
    round(): Rectangle$1;
    union(r: Rectangle$1): Rectangle$1;
    normalize(): Rectangle$1;
    intersects(r: Rectangle$1): boolean;
    toString(): string;
}

/** @internal */
declare class Point$1 {
    x: number;
    y: number;
    static empty(): Point$1;
    static create(x?: number, y?: number): Point$1;
    constructor(x?: number, y?: number);
    /** isEmpty */
    get isEmpty(): boolean;
    clone(): Point$1;
    equals(sz: Point$1): boolean;
    setEmpty(): Point$1;
    set(x: number, y: number): Point$1;
    round(): Point$1;
    toString(): string;
}

/** @internal */
interface UIToolOwner {
}
/** @internal */
declare class UITool extends Base$1 {
    private _owner;
    private _name;
    private _previous;
    private _dragTracker;
    private _clickX;
    private _clickY;
    private _pointerX;
    private _pointerY;
    private _pointerEventTarget;
    protected _lastTouch: number;
    constructor(owner: UIToolOwner, name: string);
    protected _doDispose(): void;
    /** owner */
    get owner(): UIToolOwner;
    /** name */
    get name(): string;
    /** previous */
    get previous(): UITool;
    /** dragTracker */
    get dragTracker(): UIDragTracker;
    set dragTracker(value: UIDragTracker);
    /** dragging */
    get dragging(): boolean;
    /** pointerX */
    get pointerX(): number;
    /** pointerY */
    get pointerY(): number;
    activate(previous: UITool): void;
    deactivate(): void;
    keyDown(event: KeyboardEvent): boolean;
    keyUp(event: KeyboardEvent): boolean;
    keyPress(event: KeyboardEvent): boolean;
    pointerDown(event: PointerEvent): boolean;
    dragFrom(event: PointerEvent, tracker: UIDragTracker): void;
    dropFrom(event: PointerEvent, tracker: UIDragTracker): void;
    pointerMove(event: PointerEvent): void;
    pointerUp(event: PointerEvent): void;
    pointerEnter(event: PointerEvent): void;
    pointerLeave(event: PointerEvent): void;
    pointerOver(event: PointerEvent): void;
    pointerOutside(): void;
    mouseWheel(event: MouseEvent): boolean;
    contextMenu(event: PointerEvent): boolean;
    click(event: PointerEvent): void;
    dblclick(event: PointerEvent): void;
    setFocus(target?: HTMLElement): void;
    focusLeave(event: Event): void;
    protected get pointerEventTarget(): HTMLElement;
    protected ispointerEventTarget(elt: UIElement): boolean;
    protected _doActivated(previous: UITool): void;
    protected _doDeactivated(): void;
    protected _doKeyDown(event: KeyboardEvent): boolean;
    protected _doKeyUp(event: KeyboardEvent): boolean;
    protected _doKeyPress(event: KeyboardEvent): boolean;
    /**
     * true 리턴하면 preventDefault 호출.
     */
    protected _doPointerDown(event: PointerEvent | TouchEvent): boolean;
    protected _doPointerMove(event: PointerEvent | TouchEvent): void;
    /** 그리드 밖에서도 호출된다. */
    protected _doPointerUp(event: PointerEvent | TouchEvent): void;
    protected _doPointerEnter(event: PointerEvent): void;
    protected _doPointerLeave(event: PointerEvent): void;
    protected _doPointerOver(event: PointerEvent): void;
    protected _doPointerOutside(): void;
    protected _doMouseWheel(event: MouseEvent): boolean;
    protected _doContextMenu(event: PointerEvent): boolean;
    /** 그리드 밖에서 마우스를 놓으면 호출되지 않는다. */
    protected _doClick(event: PointerEvent): void;
    protected _doDblClick(event: PointerEvent): void;
    protected _doSetFocus(target?: HTMLElement): void;
    protected _doFocusLeave(event: Event): void;
    protected _getUIDragTracker(request: UIEditRequest, x: number, y: number): UIDragTracker;
    protected _startDragTracker(event: PointerEvent, x: number, y: number, shift: boolean, alt: boolean): void;
    protected _stopDragTracker(event: PointerEvent, x: number, y: number, canceled: boolean): void;
    protected _doDragTrackerStarted(UIDragTracker: UIDragTracker): void;
    protected _doDragTrackerFinished(UIDragTracker: UIDragTracker, canceled: boolean): void;
}
/** @internal */
declare abstract class UIEditRequest extends Base$1 {
    constructor();
    /** cursor */
    get cursor(): Cursor$1;
    /** source */
    get source(): any;
    /** selectable */
    get selectable(): boolean;
    /** dblClickable */
    get dblClickable(): boolean;
}
/** @internal */
declare class UIDragTracker extends Base$1 {
    private _container;
    private _name;
    private _active;
    private _completed;
    private _dragging;
    private _startX;
    private _startY;
    private _currentX;
    private _currentY;
    constructor(container: UIContainer, name: string);
    /** container */
    get container(): UIContainer;
    /** name */
    get name(): string;
    /** active */
    get active(): boolean;
    /** dragging */
    get dragging(): boolean;
    /** startWhenCreated */
    get startWhenCreated(): boolean;
    /** completed */
    get completed(): boolean;
    /**
     * linkable proprerty.
     * 다른 그리드에서 진행 가능한 tracker.
     */
    get linkable(): boolean;
    activate(): void;
    deactivate(): void;
    start(event: PointerEvent, eventTarget: HTMLElement, x: number, y: number, shift: boolean, alt: boolean): boolean;
    drag(eventTarget: HTMLElement, x: number, y: number): boolean;
    cancel(event: PointerEvent): void;
    drop(event: PointerEvent, eventTarget: HTMLElement, x: number, y: number): void;
    getRequest(): UIEditRequest;
    getNextRequest(x: number, y: number): UIEditRequest;
    protected get startX(): number;
    protected get startY(): number;
    protected get currentX(): number;
    protected get currentY(): number;
    protected _showFeedback(x: number, y: number): void;
    protected _moveFeedback(x: number, y: number): void;
    protected _hideFeedback(): void;
    protected _doActivate(): void;
    protected _doDeactivate(): void;
    protected _doStart(event: PointerEvent, eventTarget: HTMLElement, x: number, y: number, shfit: boolean, alt: boolean): boolean;
    protected _doDrag(eventTarget: HTMLElement, x: number, y: number): boolean;
    protected _doCanceled(x: number, y: number): void;
    protected _canAccept(eventTarget: HTMLElement, x: number, y: number): boolean;
    protected _doCompleted(eventTarget: HTMLElement, x: number, y: number): void;
    protected _doEnded(event: PointerEvent): void;
}

declare class UIElement extends EventAware$1 {
    userData: any;
    private _parent;
    private _dom;
    private _elements;
    constructor(doc: Document, className: string, elementType?: string);
    get dom(): HTMLElement;
    /** parent */
    get parent(): UIElement;
    /** container */
    get container(): UIContainer;
    /** x */
    get x(): number;
    set x(value: number);
    /** y */
    get y(): number;
    set y(value: number);
    /** width */
    get width(): number;
    /** height */
    get height(): number;
    isDom(dom: Element): boolean;
    setClassName(className: string): void;
    setHint(title: string): void;
    setStyle(style: string, value: string): void;
    clearStyle(style: string): void;
    setStyles(styles: object): void;
    setImportantStyle(style: string, value: any): void;
    getBounds(): IRect;
    setBounds(x: number, y: number, width: number, height: number): void;
    setRect(r: IRect): void;
    move(x: number, y: number): UIElement;
    setXP(x: number): void;
    setYP(y: number): void;
    contains(dom: Element | UIElement): boolean;
    appendDom(dom: Element): void;
    clear(): this;
    addChild(child: UIElement): boolean;
    removeChild(child: UIElement): boolean;
    removeLast(): UIElement;
    containerToLocal(x?: number, y?: number): {
        x: number;
        y: number;
    };
    setText(text: string): this;
    hide(): this;
    show(style?: string): this;
    setRotation(rotation: number): this;
    protected _addChild(child: UIElement): void;
    protected _removeChild(child: UIElement): boolean;
    protected _initDom(doc: Document, dom: HTMLElement): void;
}
/** @internal */
declare abstract class UIContainer extends EventAware$1 {
    private _activeTool;
    private _containerDiv;
    private _layoutNeeded;
    private _defaultTool;
    private _defaultCursor;
    private _eventHandlers;
    private _eventNodes;
    private _doc;
    private _root;
    private _requestTimer;
    private _containerRender;
    private _saveDisplay;
    constructor(containerId: string | HTMLDivElement);
    protected _doDispose(): void;
    /** Document */
    get doc(): Document;
    /** visible */
    get visible(): boolean;
    set visible(value: boolean);
    /** activeTool */
    get activeTool(): UITool;
    set activeTool(value: UITool);
    /** defaultTool */
    get defaultTool(): UITool;
    /** width */
    get width(): number;
    set width(value: number);
    /** height */
    get height(): number;
    set height(value: number);
    getBound(): Rectangle$1;
    getHtml(): string;
    setCursor(cursor?: string): void;
    contains(dom: any): boolean;
    protected abstract _getCssSelector(): string;
    private prepareContainer;
    protected _addElement(element: UIElement): void;
    protected _prepareContainer(div: HTMLDivElement): void;
    protected _prepareChildren(doc: Document, dom: HTMLElement): void;
    protected _createDefaultTool(): UITool;
    isLayoutNeeded(): boolean;
    invalidateLayout(): void;
    updateNow(): void;
    protected _render(timestamp: number): void;
    private $$_render;
    protected _doLayout(doc: Document, bounds: Rectangle$1): void;
    protected _doPrepareRender(bounds: Rectangle$1): void;
    protected _doRenderHtml(bounds: Rectangle$1): void;
    _registerEventHandlers(container: HTMLElement): void;
    $_addListener(node: any, event: any, handler: any, capture: any): void;
    $_removeListener(node: any, event: any): void;
    $_removeListenerAll(node?: HTMLElement): void;
    private _unloadHandler;
    private _resizeHandler;
    protected _doResized(event: Event): void;
    protected _isEnabled(): boolean;
    private _keyDownHandler;
    private _keyUpHandler;
    private _keyPressHandler;
    eventToContainer(event: any): Point$1;
    private toOffset;
    private _clickHandler;
    private _dblclickHandler;
    private $_getHtmlElement;
    private _pointerDownHandler;
    private _pointerMoveHandler;
    private _pointerUpHandler;
    private _pointerEnterHandler;
    private _pointerLeaveHandler;
    private _pointerOverHandler;
    private _contextMenuHander;
    private _wheelHandler;
    private _focusHandler;
    private _blurHandler;
    private _selectstartHandler;
    private _focusinHandler;
    private _globalPointerDownHandler;
    private _focusoutHandler;
    private _focusHandlerFireFox;
}

/** @internal */
declare abstract class VisualContainer$1 extends EventAware$1 implements VisualToolOwner$1 {
    static readonly FEEDBACK_ZINDEX = 1000;
    private static $_Containers;
    static $_mouseContainer: number;
    getMouseContainer(): VisualContainer$1;
    private static $_ActiveGrid;
    static getActiveGrid(): any;
    static setActiveGrid(hash: number): void;
    static clearContainer(hash: number): void;
    static disposeStatic(): void;
    private _disabled;
    private _activeTool;
    private _containerDiv;
    private _containerDom;
    private _measurer;
    private _textMeasurer;
    private _checkMeasurer;
    private _checkRect;
    private _updateRequested;
    private _layoutNeeded;
    private _invalidated;
    private _scrolling;
    private _defaultTool;
    private _captured;
    private _focusing;
    private _focusingTarget;
    private _hovered;
    private _currentX;
    private _currentY;
    private _rendered;
    private _defaultCursor;
    private _drawing;
    private _offsetX;
    private _offsetY;
    private _rootElement;
    private _feedbackElement;
    private _eventHandlers;
    private _eventNodes;
    private _containerRender;
    private _scrollTool;
    private _cursor;
    private _testWidth;
    private _testHeight;
    private _requestTimer;
    private _doc;
    private _saveDisplay;
    private $_testing;
    constructor(containerId: string | HTMLDivElement);
    protected _initContainer(containerId: string | HTMLDivElement): void;
    protected _doDispose(): void;
    /** document */
    get doc(): Document;
    /** dom */
    get dom(): HTMLElement;
    /** visible */
    get visible(): boolean;
    set visible(value: boolean);
    /** contentVisible */
    get contentVisible(): boolean;
    set contentVisible(value: boolean);
    /** disabled */
    get disabled(): boolean;
    set disabled(value: boolean);
    /** printing */
    get printing(): boolean;
    /** activeTool */
    get activeTool(): VisualTool$1;
    set activeTool(value: VisualTool$1);
    /** defaultTool */
    get defaultTool(): VisualTool$1;
    /** measurer */
    protected get measurer(): HTMLElement;
    /** width */
    get width(): number;
    set width(value: number);
    /** height */
    get height(): number;
    set height(value: number);
    get scrollHeight(): number;
    get scrollTop(): number;
    protected get scrolling(): boolean;
    get containerDiv(): HTMLDivElement;
    protected get root(): VisualElement$1;
    findElementAt(x: number, y: number, hitTesting: boolean, blockLayer: boolean): VisualElement$1;
    findElementOf(dom: Element, deep?: boolean): VisualElement$1;
    getTableCell(dom: HTMLElement): HTMLTableCellElement;
    setCursor(cursor: string): void;
    setFocus(): void;
    updateNow(): void;
    toScreen(r: Rectangle$1): Rectangle$1;
    pointToScreen(x: number, y: number): {
        x: number;
        y: number;
    };
    getBound(): Rectangle$1;
    getHtml(): string;
    appendDom(dom: HTMLElement): void;
    addElement(element: VisualElement$1): boolean;
    removeElement(element: VisualElement$1): boolean;
    addFeedback(element: UIElement | HTMLElement): boolean;
    addFeedbacks(...elements: (UIElement | HTMLElement)[]): void;
    removeFeedback(element: UIElement | HTMLElement): boolean;
    removeFeedbacks(...elements: (UIElement | HTMLElement)[]): void;
    resetSize(callback?: any): void;
    measureText(style: string, text: string): number;
    private $_refreshCheckMeasurer;
    measureCheckWidth(): number;
    measureCheckHeight(): number;
    contains(target: any): boolean;
    getDomPosition(elt: HTMLElement | VisualElement$1, rotated?: boolean): IRect;
    private $_offsetDomPosition;
    getBoundingRect(element: VisualElement$1): Rectangle$1;
    domToContainer(dom: Element): IRect;
    get feedbackElement(): UIElement;
    private $_setTesting;
    protected get _isTesting(): boolean;
    protected _doDisabledChanged(): void;
    private $_prepareContainer;
    protected _doPrepareContainer(doc: Document, dom: HTMLElement): void;
    protected _doPrepareContent(doc: Document, root: HTMLDivElement): void;
    protected _createRootElement(doc: Document): VisualElement$1;
    protected _createDefaultTool(): VisualTool$1;
    isLayoutNeeded(): boolean;
    invalidateLayout(scrolling?: boolean): void;
    invalidate(force: boolean): void;
    invalidateElement(element: VisualElement$1): void;
    invalidateElements(force?: boolean): void;
    refresh(): void;
    protected _render(timestamp: number): void;
    private $$_render;
    protected _layoutChildren(bounds: Rectangle$1): void;
    protected _doLayout(bounds: Rectangle$1): void;
    protected _doAfterRender(): void;
    protected _doRenderHtml(bounds: Rectangle$1): void;
    protected _doDrawContainer(bounds: Rectangle$1): void;
    protected _drawElement(element: VisualElement$1): void;
    private _validateChildren;
    _registerEventHandlers(container: HTMLElement): void;
    $_addListener(node: any, event: any, handler: any, capture: any): void;
    $_removeListener(node: any, event: any): void;
    $_removeListenerAll(node?: HTMLElement): void;
    private _unloadHandler;
    private _resizeHandler;
    protected _doResized(event: Event): void;
    protected _isEnabled(): boolean;
    private _keyDownHandler;
    protected _doKeyDown(ev: KeyboardEvent): boolean;
    private _keyUpHandler;
    private _keyPressHandler;
    eventToContainer(event: any): Point$1;
    private toOffset;
    private toOffsetTouch;
    protected _doClick(event: MouseEvent): boolean;
    private _clickHandler;
    private _dblclickHandler;
    private $_getHtmlElement;
    protected _isAutoFocus(): boolean;
    private _mouseDownHandler;
    private _mouseMoveHandler;
    private _mouseUpHandler;
    private _mouseEnterHandler;
    _mouseLeaveHandler(event: MouseEvent): void;
    private _mouseOverHandler;
    /**
     * - 드래그 하는동안은 MouseMove가 발생하지 않기 때문에 Start End를 제외하고 타겟을 직접 넣어준다.
     * @param event
     */
    private _dragStartHandler;
    private _dragEndHandler;
    private _dragOverHandler;
    private _dragEnterHandler;
    private _dragLeaveHandler;
    private _dragDropHandler;
    private _contextMenuHander;
    protected _wheelHandler(event: WheelEvent): void;
    protected _focusHandler(event: FocusEvent): void;
    protected _blurHandler(event: FocusEvent): void;
    private _selectstartHandler;
    private _focusinHandler;
    private _globalMouseDownHandler;
    private _focusoutHandler;
    private _focusHandlerFireFox;
}

type VisualElementCallback = (element: VisualElement$1, dom: HTMLElement) => void;
/** @internal */
declare abstract class VisualElement$1 extends EventAware$1 {
    private static readonly Testing;
    private static readonly Logging;
    static log(message: string, level?: 'error' | 'warn' | 'info'): void;
    private _positionable;
    private _x;
    private _y;
    private _width;
    private _height;
    private _visible;
    private _styleName;
    private _name;
    private _parent;
    private _elements;
    private _dom;
    private _dirty;
    private _className;
    _nodraw: boolean;
    constructor(doc: Document, name?: string, callback?: VisualElementCallback);
    protected _doDispose(): void;
    /** positionable */
    get positionable(): boolean;
    set positionable(value: boolean);
    /** name */
    get name(): string;
    /** styleName */
    get styleName(): string;
    set styleName(value: string);
    /** container */
    get container(): VisualContainer$1;
    /** parent */
    get parent(): VisualElement$1;
    /** elements */
    get elements(): VisualElement$1[];
    /** childCount */
    get childCount(): number;
    /** isSingleton */
    get isSingleton(): boolean;
    /** x */
    get x(): number;
    set x(value: number);
    /** y */
    get y(): number;
    set y(value: number);
    /** width */
    get width(): number;
    set width(value: number);
    /** height */
    get height(): number;
    set height(value: number);
    /** right */
    get right(): number;
    /** bottom */
    get bottom(): number;
    /** position */
    get position(): Point$1;
    /** bounds */
    get bounds(): Rectangle$1;
    /** clientRect */
    get clientRect(): Rectangle$1;
    /** visible */
    get visible(): boolean;
    set visible(value: boolean);
    interalSetVisible(value: boolean): boolean;
    setVisible(value: boolean, style?: string): boolean;
    /** findable */
    get findable(): boolean;
    /** isLayer */
    get isLayer(): boolean;
    /**
     * blockable
     * true이면 isLayer일 때도 findElementAt에서 hit test될 수 있다.
     */
    get blockable(): boolean;
    /** mouseX */
    get mouseX(): number;
    /** mouseY */
    get mouseY(): number;
    /** dom */
    get dom(): HTMLElement;
    /** doc */
    get doc(): Document;
    /** style */
    protected get style(): CSSStyleDeclaration;
    /** offsetWidth */
    get offsetWidth(): number;
    /** offsetHeight */
    get offsetHeight(): number;
    /** offsetSize */
    get offsetSize(): {
        width: number;
        height: number;
    };
    get printable(): boolean;
    isDom(dom: Element): boolean;
    containsDom(dom: Element): boolean;
    containsClass(className: string): boolean;
    getChildren(): VisualElement$1[];
    getChild(index: number): VisualElement$1;
    indexOf(element: VisualElement$1): number;
    get firstChild(): VisualElement$1;
    contains(element: VisualElement$1): boolean;
    getAncestor(cls: any): VisualElement$1;
    addDom<T extends Element>(dom: T): T;
    insertDom(dom: Element, elt: VisualElement$1): void;
    addChild(child: VisualElement$1): boolean;
    protected _getParentDom(): HTMLElement;
    insertChild(index: number, child: VisualElement$1): boolean;
    remove(): void;
    removeChild(child: VisualElement$1): boolean;
    removeChildAt(index: number): VisualElement$1;
    removeLast(): VisualElement$1;
    clear(): boolean;
    hideAll(): void;
    invalidate(force?: boolean, invalidateChildren?: boolean): void;
    validate(): void;
    invalidateLayout(): void;
    getBounds(r?: Rectangle$1): Rectangle$1;
    getClientRect(r?: Rectangle$1): Rectangle$1;
    containsInBounds(x: number, y: number): boolean;
    containsInClient(x: number, y: number): boolean;
    parentToElement(parent: VisualElement$1, x: number, y: number): Point$1;
    translateBy(descendant: VisualElement$1, r?: Rectangle$1): Rectangle$1;
    topBy(parent: VisualElement$1, top: number): number;
    boundsBy(parent: VisualElement$1, r?: Rectangle$1): Rectangle$1;
    boundsByContainer(r?: Rectangle$1): Rectangle$1;
    pointByContainer(x: number, y: number): Point$1;
    containerToElement(x: number, y: number): Point$1;
    boundsByScreen(r?: Rectangle$1): Rectangle$1;
    offsetFrom(elt: VisualElement$1): Point$1;
    hitTest(x: number, y: number): boolean;
    findChildAt(x: number, y: number, hitTesting: boolean, blockLayer: boolean): VisualElement$1;
    findChildOf(dom: Element, deep: boolean): VisualElement$1;
    internalSetX(x: number): void;
    internalSetY(y: number): void;
    move(x: number, y: number, draw?: boolean): void;
    internalMove(x: number, y: number): void;
    moveBy(dx: number, dy: number, draw?: boolean): void;
    resize(width: number, height: number, draw?: boolean): void;
    setSize(width: number, height: number): void;
    resizeBy(dw: number, dh: number, draw?: boolean): void;
    setBounds(x: number, y: number, width: number, height: number): VisualElement$1;
    setBoundsI(x: number, y: number, width: number, height: number): VisualElement$1;
    setRect(r: IRect): VisualElement$1;
    internalSetRect(r: IRect): VisualElement$1;
    setRectI(r: IRect): VisualElement$1;
    getBoundingRect(): {
        x: number;
        y: number;
        left: number;
        right: number;
        width: number;
        top: number;
        bottom: number;
        height: number;
    };
    draw(force?: boolean): void;
    drawRecursive(): void;
    resetSizeStyle(): void;
    getHtml(): string;
    setImportantStyle(style: string, value: any): void;
    isAncestorOf(child: VisualElement$1): boolean;
    isAncestorDomOf(child: HTMLElement, checkThis?: boolean): boolean;
    findDescendantOf(dom: HTMLElement): VisualElement$1;
    setStyles(styles: any): void;
    get scrollTop(): number;
    get scrollLeft(): number;
    scrollDom(x: number, y: number): void;
    setHint(title: string): void;
    setRotation(rotation: number): void;
    setFocus(): void;
    protected _isTesting(): boolean;
    protected _getElements(): VisualElement$1[];
    protected _createDom(doc: Document): HTMLElement;
    protected _getCssSelector(): string;
    protected _initDom(doc: Document, dom: HTMLElement): void;
    protected _addEventListeners(dom: HTMLElement): void;
    protected _removeEventListeners(dom: HTMLElement): void;
    private $_attached;
    protected _doAttached(parent: VisualElement$1): void;
    private $_detached;
    protected _doDetached(parent: VisualElement$1): void;
    protected _isEmptySize(): boolean;
    protected _setSizeStyle(css: CSSStyleDeclaration): void;
    setPrintStyles(): void;
    protected _getCssDisplay(): string;
    resetStyleName(): void;
    protected _setClassName(dom: HTMLElement, className?: string): void;
    replaceDom(dom: HTMLElement): void;
    cloneNode(): Node;
    applyBounds(): void;
    protected _beforeDraw(dom: HTMLElement): void;
    protected _doDraw(dom: HTMLElement): void;
    protected _afterDraw(dom: HTMLElement): void;
    protected _visibleChanged(): void;
    private sizeChanged;
    protected _doSizeChanged(): void;
}
/** @internal */
declare class LayerElement$1 extends VisualElement$1 {
    get isLayer(): boolean;
    protected _doDraw(element: HTMLElement): void;
}

interface ISize {
    width: number;
    height: number;
}
/** @internal */
declare class Size$1 implements ISize {
    width: number;
    height: number;
    static readonly EMPTY: Size$1;
    static empty(): Size$1;
    static create(w?: number, h?: number): Size$1;
    constructor(width?: number, height?: number);
    /** isEmpty */
    get isEmpty(): boolean;
    clone(): Size$1;
    equals(sz: Size$1): boolean;
    setEmpty(): Size$1;
    set(width: number, height: number): Size$1;
    round(): Size$1;
    toString(): string;
}

/**
 * Property 모델 구성 요소.
 */
declare abstract class PropertyItem extends Base$1 {
    private _prop;
    private _group;
    constructor(prop: IPropInfo);
    get group(): PropertyGroup;
    get prop(): IPropInfo;
    get name(): string;
    get label(): string;
    get domain(): any[];
    get parent(): any;
    isVisible(source: IPropertySource): boolean;
    isReadOnly(source: IPropertySource): boolean;
    getValue(source: IPropertySource): any;
    getValueByName(name: string, source: IPropertySource): any;
    setValue(source: IPropertySource, value: any): void;
    setValues(sources: IPropertySource[], value: any): void;
    setValueByName(name: string, source: IPropertySource, value: any): void;
    setValuesByName(name: string, sources: IPropertySource[], value: any): void;
    hasColor(): boolean;
}
declare class PropertyGroup extends Base$1 {
    static readonly $_ctor: string;
    private _label;
    private _items;
    private _pool;
    source: IPropertySource;
    constructor(label: string);
    get label(): string;
    get count(): number;
    get(index: number): PropertyItem;
    borrow(info: IPropInfo): PropertyItem;
    find(name: string): PropertyItem;
    add(item: PropertyItem): void;
    clear(): void;
}
/**
 * Value property base.
 */
declare abstract class ValueProperty extends PropertyItem {
    private _defaultValue;
    /**
     * 기본값.
     */
    get defaultValue(): any;
    set defaultValue(value: any);
}
/**
 * String property.
 */
declare class StringProperty extends ValueProperty {
    static readonly $_ctor: string;
}
/**
 * 참조 항목 list를 갖는 property.
 */
declare class ListableProperty extends StringProperty {
    static readonly $_ctor: string;
}

interface IPropertySource {
    getEditProps(): IPropInfo[];
    getStyleProps(): IPropInfo[];
    getSubStyleProps(prop: string): IPropInfo[];
    isDominantProp(prop: IPropInfo): boolean;
    getPlaceHolder(prop: IPropInfo): string;
    getPropDomain(prop: IPropInfo): any[];
    getProperty(prop: string): any;
    setProperty(prop: string, value: any): void;
    setItemsProperty(sources: IPropertySource[], prop: string, value: any): void;
    getStyleProperty(prop: string): any;
    setStyleProperty(prop: string, value: any): void;
    setItemsStyleProperty(sources: IPropertySource[], prop: string, value: any): void;
    getSubStyleProperty(prop: string, style: string): any;
    setSubStyleProperty(prop: string, style: string, value: any): void;
    setItemsSubStyleProperty(sources: IPropertySource[], prop: string, style: string, value: any): void;
    isReadOnlyProperty(prop: IPropInfo): boolean;
    canPropAdoptDragSource(prop: IPropInfo, source: any): boolean;
    adoptPropDragSource(prop: IPropInfo, source: any): IDropResult;
    getCollapsedPropCategories?: () => string[];
    isCollectionProp(): boolean;
    isEditableCollection(): boolean;
    isCollectionItem(): boolean;
    getCollectionLabel(): string;
    getPropertySources(): IPropertySource[];
    getPopupPropLabel(prop: string): string;
}
interface IPropertyContainer {
    addCollectionItem(collection: IPropertySource): void;
    removeItem(item: IPropertySource): void;
}
declare enum PropCategory {
    DESIGN = "design",
    BASIC = "basic",
    TEXT = "text",
    DATA = "data",
    BOUND = "bound",
    LINK = "link",
    EVENT = "event",
    I18N = "internationalization",
    EDITING = "editing",
    CHECK = "check",
    SECTION = "section",
    EDITOR = "editor",
    REPORT = "report",
    PAPER = "paper",
    PRINT = "print",
    BOX = "box",
    TABLE = "table",
    BARCODE = "barcode",
    CELL = "cell",
    BAND = "band",
    BAND_GROUP = "band group",
    BAND_CELL = "band cell",
    SUB_BAND = "sub band",
    FIELD = "field",
    COLUMN = "column",
    ROW = "row",
    CHART = "chart",
    TITLE = "title",
    SUBTITLE = "subtitle",
    AXIS = "axis",
    XAXIS = "x Axis",
    YAXIS = "y Axis",
    SERIES = "series",
    LABEL = "label",
    LABELS = "labels",
    DATA_LABELS = "dataLabels",
    MARKER = "marker",
    LEGEND = "legend",
    SHEET = "sheet",
    GRID = "grid",
    LINE = "line",
    TICK = "tick",
    POINT = "point",
    TOOLTIP = "tooltip",
    CROSSHAIR = "crosshair",
    OPTIONS = "options",
    BODY = "body",
    CREDITS = "credits",
    COLOR_SCALE = "colorScale",
    MAP = "map",
    STYLES = "Styles",
    EMAIL_FORM_INFO = "email form info",
    EMAIL_LAYOUT = "email layout",
    EXCEL = "excel",
    EXCEL_BAR = "bar"
}
interface IPropInfo {
    name: string;
    category: string;
    type: any;
    typeProps?: any | ModelPropertyTypeProps;
    parent?: string;
    indented?: boolean;
    calculated?: boolean;
    collection?: boolean;
    visible?: (source: IPropertySource) => boolean;
    multiple?: boolean;
    /**
     * 속성 기본값
     * - 속성값이 `default` 값과 일치하면 양식에 저장하지 않는다.
     *   - 이메일 아이템의 경우에는 로드할 때, 양식에 해당 속성 필드가 정의되어 있지 않으면 `default` 값으로 로드한다. (`EmailLoaderImpl.loadOwn()` 참고)
     * - 명시적으로 `undefined`값을 할당해야 `undefined`를 기본값으로 처리한다. 반면 `default` 필드를 정의하지 않는 경우는 기본값 로직이 동작하지 않는다.
     * - inspector에서 reset 시에도 활용된다.
     */
    default?: any;
    /**
     * 속성값 변경 가능 여부
     * - `true`면 값을 변경할 수 없고, 양식에서 로드되지 않는다.
     */
    readonly?: boolean;
    domain?: any[] | any;
    label?: string;
    tag?: string;
    params?: any;
    signature?: string;
    validate?: (source: IPropertySource, inputValue: any) => void;
    refresh?: boolean;
    description?: string;
    expandable?: boolean;
}
/**
 * Report 혹은 ReportItem들의 속성 집합 모델.
 */
declare class PropertyModel extends EventAware$1 {
    static readonly SOURCE_CHANGED = "onPropertySourceChanged";
    static readonly VALUE_CHANGED = "onPropertyValueChanged";
    private _name;
    private _modelMap;
    private _groupMap;
    private _styleGroup;
    private _childStyleMap;
    private _source;
    private _sources;
    private _groups;
    private _models;
    private _includedPropNames;
    constructor(name?: string);
    get name(): string;
    /** source */
    get source(): IPropertySource;
    set source(value: IPropertySource);
    /**
     * 리포트에서 복수 선택시 설정된다.
     */
    get sources(): IPropertySource[];
    set sources(value: IPropertySource[]);
    /** groupCount */
    get groupCount(): number;
    /**
     * sub model count
     */
    get modelCount(): number;
    /**
     * 현재 모델에 포함해야 할 속성을 정의 (undefined일 경우에는 모든 속성을 포함, 빈 배열을 모든 속성 무시)
     */
    get includedPropNames(): string[] | undefined;
    set includedPropNames(value: string[] | undefined);
    getGroup(index: number): PropertyGroup;
    getModel(index: number): PropertyModel;
    findItem(prop: string): PropertyItem;
    refresh(): void;
    updateValue(source: IPropertySource, item: PropertyItem, value: any): void;
    updateValueByName(name: string, source: IPropertySource, item: PropertyItem, value: any): void;
    private $_borrowGroup;
    private $_borrowModel;
    private $_clear;
    private $_buildSource;
    private $_buildModels;
    private $_buildItems;
    private $_isIncludeProp;
    protected _fireSourceChanged(): void;
    protected _fireValueChanged(source: IPropertySource, item: PropertyItem, value: any): void;
}
interface ModelPropertyTypeProps {
    /**
     * 포함해야할 모델 내부 속성을 정의
     */
    include?: string[];
}
/**
 * Sub property model property.
 */
declare class ModelProperty extends PropertyItem {
    static readonly $_ctor: string;
    private _model;
    constructor(prop: IPropInfo);
    /** model */
    get model(): PropertyModel;
}

/**
 * 자식 item들을 순서대로 쌓아가며 배치한다.
 * 위치 설정이 안된 item은 중앙에 정렬 시킨다.
 */
declare class StackContainer extends BoundedContainer {
    static readonly PROP_OVERFLOW = "overflow";
    static readonly PROPINFOS: IPropInfo[];
    static readonly $_ctor: string;
    static readonly ITEM_TYPE = "Stack Container";
    static readonly STYLE_PROPS: string[];
    private _overflow;
    constructor(name: string);
    /**
     * true로 설정되면 자식이 넘칠 수 있다.
     * 특히, table을 자식으로 갖는 경우 true로 설정해야 우측 끝이 표시되는 경우가 있을 수 있다.
     */
    get overflow(): boolean;
    set overflow(value: boolean);
    canOverflow(): boolean;
    get outlineLabel(): string;
    getSaveType(): string;
    protected _datable(): boolean;
    protected _doDefaultInit(loader: IReportLoader, parent: ReportGroupItem, hintWidth: number, hintHeight: number): void;
    protected _getStyleProps(): string[];
    protected _getEditProps(): IPropInfo[];
    protected _doLoad(loader: IReportLoader, src: any): void;
    protected _doSave(target: object): void;
    canAlign(child: ReportItem): boolean;
    canAdoptDragSource(source: any): boolean;
    getMoveType(item: ReportItem): ItemMoveType;
}

/**
 * Report 편집 command base.
 */
declare abstract class ReportEditCommand extends EditCommand$1 {
    get page(): ReportPageBase;
}

/**
 * Asset item base.
 */
declare abstract class AssetItem implements IPropertySource {
    name: string;
    data: string;
    static readonly PROP_NAME = "name";
    static readonly PROP_INFOS: {
        name: string;
        category: PropCategory;
        type: typeof StringProperty;
        multiple: boolean;
        default: any;
    }[];
    parent: AssetGroup;
    description: string;
    tag: any;
    constructor(name: string, data: string);
    getEditProps(): IPropInfo[];
    getStyleProps(): IPropInfo[];
    getSubStyleProps(prop: string): IPropInfo[];
    isDominantProp(prop: IPropInfo): boolean;
    getPlaceHolder(prop: IPropInfo): string;
    getPropDomain(prop: IPropInfo): any[];
    getProperty(prop: string): any;
    setProperty(prop: string, value: any): void;
    setItemsProperty(sources: IPropertySource[], prop: string, value: any): void;
    getStyleProperty(prop: string): void;
    setStyleProperty(prop: string, va