import * as _angular_core from '@angular/core';
import { ChangeDetectorRef, Signal, TemplateRef, OutputEmitterRef, InjectionToken, OnInit, ElementRef, OnChanges, WritableSignal, Renderer2, NgZone, AfterViewInit, QueryList, PipeTransform, OnDestroy } from '@angular/core';
import * as i1$1 from 'ngx-tethys/tooltip';
import * as i2 from 'ngx-tethys/icon';
import * as i3 from 'ngx-tethys/action';
import * as i4 from 'ngx-tethys/shared';
import * as i5 from '@angular/common';
import * as i1 from '@angular/cdk/scrolling';
import { CdkVirtualScrollViewport, CdkScrollable, ScrollDispatcher } from '@angular/cdk/scrolling';
import { ListRange } from '@angular/cdk/collections';
import { CdkDrag, CdkDropList, CdkDragStart, CdkDragDrop, DragRef, DragDropRegistry } from '@angular/cdk/drag-drop';
import { Observable } from 'rxjs';
import * as _tethys_pro_i18n from '@tethys/pro/i18n';
import { SharedResizeObserver } from '@angular/cdk/observers/private';
import { SafeAny } from 'ngx-tethys/types';
import { CdkAutoSizeVirtualScroll, AutoSizeVirtualScrollStrategy, ItemSizeAverager } from '@angular/cdk-experimental/scrolling';
import * as _tethys_pro_board from '@tethys/pro/board';

interface ThyBoardLane {
    _id: string;
    name: string;
    cards?: ThyBoardCard[];
    entries?: ThyBoardEntry[];
    expanded?: boolean;
}
interface ThyBoardEntry {
    _id: string;
    name: string;
    wipLimit?: number;
    split?: boolean;
    cards?: ThyBoardCard[];
    expanded?: boolean;
    droppableZones?: ThyBoardZone[];
}
declare enum ThyBoardEntryStatus {
    doing = 1,
    done = 2
}
interface ThyBoardCard {
    _id: string;
    laneIds: string[];
    entryIds: string[];
    /**
     * 添加 status，设置卡片是在进行中还是已完成栏
     * 当卡片在不同的栏和泳道中状态相同时，支持直接设置 ThyBoardEntryStatus
     * 当卡片在不同的泳道和栏中有不同的状态时，支持设置  {laneId?: string, entryId: string, state: ThyBoardEntryStatus}[]
     */
    status?: {
        laneId?: string;
        entryId: string;
        state: ThyBoardEntryStatus;
    }[] | ThyBoardEntryStatus;
    [key: string]: any;
}
interface ThyBoardVirtualScrolledIndexChangeEvent {
    renderedRange: ListRange;
    entry: ThyBoardEntry;
    lane?: ThyBoardLane;
    status?: ThyBoardEntryStatus;
    nextLane?: ThyBoardLane;
    expandedLanes?: ThyBoardLane[];
}
interface ThyBoardZone {
    _id: string;
    name: string;
}

declare enum ThyBoardDragScopeType {
    entries = "entries",
    lanes = "lanes",
    all = "all"
}

interface ThyBoardSortEvent {
    cards: ThyBoardCard[];
    lane?: ThyBoardLane;
    entry: ThyBoardEntry;
}

interface ThyBoardDragContainer {
    entry: ThyBoardEntry;
    lane?: ThyBoardLane;
    cards?: ThyBoardCard[];
    card?: ThyBoardCard;
    status?: ThyBoardEntryStatus;
    zone?: ThyBoardZone;
    changeDetectorRef?: ChangeDetectorRef;
}
interface ThyBoardDragStartEvent {
    card: ThyBoardCard;
}
interface ThyBoardDragPredicateEvent {
    card: ThyBoardCard;
    container: ThyBoardDragContainer;
}
interface ThyBoardDropActionEvent {
    card: ThyBoardCard;
    previousContainer: ThyBoardDragContainer;
    previousIndex: number;
    container: ThyBoardDragContainer;
    currentIndex: number;
}

declare const THY_BOARD_ENTRY: InjectionToken<ThyBoardEntryAbstract>;
interface ThyBoardEntryAbstract {
    entry: Signal<ThyBoardEntry>;
    hasLane: Signal<boolean>;
    lane: Signal<ThyBoardLane>;
    laneHeight: Signal<number>;
    virtualScroll: Signal<boolean>;
    cardTemplateRef: Signal<TemplateRef<SafeAny>>;
    container: Signal<HTMLElement>;
    defaultCardSize: Signal<number>;
    draggingCard: Signal<CdkDrag<ThyBoardCard>>;
    hasDroppableZones: Signal<boolean>;
    cardDroppableZones: Signal<{
        laneId?: string;
        entryId: string;
        droppableZones: ThyBoardZone[];
    }[]>;
    topTemplateRef: Signal<TemplateRef<SafeAny>>;
    bottomTemplateRef: Signal<TemplateRef<SafeAny>>;
    sortable: Signal<ThyBoardDragScopeType>;
    movable: Signal<ThyBoardDragScopeType>;
    cardDraggablePredicate: Signal<(event: ThyBoardDragPredicateEvent) => boolean>;
    cardDropEnterPredicate: Signal<(event: ThyBoardDragPredicateEvent) => boolean>;
    cardDropAction: Signal<(event: ThyBoardDropActionEvent) => Observable<boolean>>;
    cardDragStarted: OutputEmitterRef<CdkDrag<ThyBoardCard>>;
    virtualScrolledIndexChange: OutputEmitterRef<ThyBoardVirtualScrolledIndexChangeEvent>;
}

declare class ThyBoardService {
    private locale;
    private cards;
    private entries;
    private lanes;
    private innerAllLanesExpanded;
    private innerEntryCollapsible;
    private hasAutoEmptyLane;
    private sortCardsInEntry;
    private emptyLane;
    private innerEmptyLane;
    private innerLanes;
    lanesWithEntriesAndCards: Signal<ThyBoardLane[]>;
    entriesWithCards: Signal<ThyBoardEntry[]>;
    entryCollapsible: Signal<boolean>;
    hasCollapsedEntry: Signal<boolean>;
    laneCollapsible: Signal<boolean>;
    allLanesExpanded: Signal<boolean>;
    constructor();
    setCards(cards: ThyBoardCard[]): void;
    setEntities(entries: ThyBoardEntry[]): void;
    setLanes(lanes: ThyBoardLane[]): void;
    setAllLanesExpanded(state: boolean): void;
    setInnerEntryCollapsible(state: boolean): void;
    setHasAutoEmptyLane(state: boolean): void;
    setSortCardsInEntry(state: (event: ThyBoardSortEvent) => ThyBoardCard[]): void;
    private buildCardsMap;
    private buildEntriesWithCards;
    private buildLanesWithEntriesAndCards;
    private buildEntriesWithCardsByLanes;
    expandEntry(event: {
        entry: ThyBoardEntry;
        expanded: boolean;
    }): void;
    expandLane(event: {
        lane: ThyBoardLane;
        expanded: boolean;
    }): void;
    expandAllLanes(event: boolean): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThyBoardService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ThyBoardService>;
}

declare class ThyBoardComponent implements OnInit {
    elementRef: ElementRef;
    thyBoardService: ThyBoardService;
    private changeDetectorRef;
    /**
     * 卡片展示模板
     * @type TemplateRef
     */
    cardTemplateRef: _angular_core.Signal<TemplateRef<any>>;
    /**
     * 栏展示模板
     * @type TemplateRef
     */
    laneTemplateRef: _angular_core.Signal<TemplateRef<any> | undefined>;
    /**
     * header 展示模板
     * @type TemplateRef
     */
    headerTemplateRef: _angular_core.Signal<TemplateRef<any> | undefined>;
    /**
     * entry 顶部展示模板
     * @type TemplateRef
     */
    entryTopTemplateRef: _angular_core.Signal<TemplateRef<any> | undefined>;
    /**
     * entry 底部展示模板
     * @type TemplateRef
     */
    entryBottomTemplateRef: _angular_core.Signal<TemplateRef<any> | undefined>;
    /**
     * 泳道列表
     * @default []
     * @type ThyBoardLane[]
     */
    thyLanes: _angular_core.InputSignal<ThyBoardLane[]>;
    /**
     * 是否自动将未在任何泳道的数据归类到“未分组”泳道中
     * @default true
     * @type boolean
     */
    thyHasAutoEmptyLane: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * 栏列表
     * @type ThyBoardEntry[]
     */
    thyEntries: _angular_core.InputSignal<ThyBoardEntry[]>;
    /**
     * 卡片列表
     * @type ThyBoardCard[]
     */
    thyCards: _angular_core.InputSignal<ThyBoardCard[]>;
    /**
     * 是否展示泳道
     * @default false
     * @type boolean
     */
    thyShowLane: _angular_core.InputSignal<boolean>;
    /**
     * 是否开启虚拟滚动
     * @default false
     * @type boolean
     */
    thyVirtualScroll: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * 卡片默认高度
     * @default false
     * @type boolean
     */
    thyDefaultCardSize: _angular_core.InputSignalWithTransform<number, unknown>;
    /**
     * 是否支持排序,开启后支持同栏排序
     * @type ThyBoardDragScopeType
     */
    thySortable: _angular_core.InputSignal<ThyBoardDragScopeType | undefined>;
    /**
     * 是否支持拖动，变更栏和泳道
     * @type ThyBoardDragScopeType
     */
    thyMovable: _angular_core.InputSignal<ThyBoardDragScopeType | undefined>;
    /**
     * 是否展开所有泳道
     * @default true
     * @type boolean
     */
    thyAllLanesExpanded: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * 是否支持栏的收起展开
     * @default false
     * @type boolean
     */
    thyEntryCollapsible: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * 在构建数据时，对栏中数据进行排序
     */
    thySortCardsInEntry: _angular_core.InputSignal<(event: ThyBoardSortEvent) => ThyBoardCard[]>;
    /**
     * 获取卡片可放置的区域
     * @type
     */
    thyCardDroppableZonesAction: _angular_core.InputSignal<((event: ThyBoardDragStartEvent) => Observable<{
        laneId?: string;
        entryId: string;
        droppableZones: ThyBoardZone[];
    }[]>) | undefined>;
    /**
     * 判断是否允许卡片拖动
     * @type (event: ThyBoardDragPredicateEvent) => boolean
     */
    thyCardDraggablePredicate: _angular_core.InputSignal<((event: ThyBoardDragPredicateEvent) => boolean) | undefined>;
    /**
     * 判断是否允许拖起的卡片放到另外位置
     * @type (event: ThyBoardDragPredicateEvent) => boolean
     */
    thyCardDropEnterPredicate: _angular_core.InputSignal<((event: ThyBoardDragPredicateEvent) => boolean) | undefined>;
    /**
     * 当把卡片拖动到另一个位置时触发
     * @type (event: CdkDragDrop<ThyBoardCard[] | undefined>) => Observable<boolean>
     */
    thyCardDropAction: _angular_core.InputSignal<((event: ThyBoardDropActionEvent) => Observable<boolean>) | undefined>;
    /**
     * 开启虚拟滚动后，滚动后触发时间，可用于加载数据
     */
    thyVirtualScrolledIndexChange: _angular_core.OutputEmitterRef<ThyBoardVirtualScrolledIndexChangeEvent>;
    /**
     * 展开收起泳道事件
     * @type { lane: ThyBoardLane; expanded: boolean }
     */
    thyExpandLane: _angular_core.OutputEmitterRef<{
        lane: ThyBoardLane;
        expanded: boolean;
    }>;
    /**
     * 展开收起所有泳道事件
     * @type { expanded: boolean }
     */
    thyExpandAllLanes: _angular_core.OutputEmitterRef<{
        expanded: boolean;
    }>;
    /**
     * 展开收起栏事件
     * @type { entry: ThyBoardEntry; expanded: boolean }
     */
    thyExpandEntry: _angular_core.OutputEmitterRef<{
        entry: ThyBoardEntry;
        expanded: boolean;
    }>;
    /**
     * 拖起卡片后触发事件
     * @type ThyBoardCard
     */
    thyCardDragStart: _angular_core.OutputEmitterRef<ThyBoardDragStartEvent>;
    cardDroppableZones: {
        laneId?: string;
        entryId: string;
        droppableZones: ThyBoardZone[];
    }[] | undefined;
    draggingCard: CdkDrag<ThyBoardCard> | undefined;
    constructor(elementRef: ElementRef, thyBoardService: ThyBoardService, changeDetectorRef: ChangeDetectorRef);
    ngOnInit(): void;
    expandAllLanes(event: boolean): void;
    expandLane(event: {
        lane: ThyBoardLane;
        expanded: boolean;
    }): void;
    expandEntry(event: {
        entry: ThyBoardEntry;
        expanded: boolean;
    }): void;
    dragCardStarted(event: CdkDrag<ThyBoardCard>): void;
    dropListDropped: (event: ThyBoardDropActionEvent) => Observable<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThyBoardComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThyBoardComponent, "thy-board", never, { "thyLanes": { "alias": "thyLanes"; "required": false; "isSignal": true; }; "thyHasAutoEmptyLane": { "alias": "thyHasAutoEmptyLane"; "required": false; "isSignal": true; }; "thyEntries": { "alias": "thyEntries"; "required": true; "isSignal": true; }; "thyCards": { "alias": "thyCards"; "required": true; "isSignal": true; }; "thyShowLane": { "alias": "thyShowLane"; "required": false; "isSignal": true; }; "thyVirtualScroll": { "alias": "thyVirtualScroll"; "required": false; "isSignal": true; }; "thyDefaultCardSize": { "alias": "thyDefaultCardSize"; "required": false; "isSignal": true; }; "thySortable": { "alias": "thySortable"; "required": false; "isSignal": true; }; "thyMovable": { "alias": "thyMovable"; "required": false; "isSignal": true; }; "thyAllLanesExpanded": { "alias": "thyAllLanesExpanded"; "required": false; "isSignal": true; }; "thyEntryCollapsible": { "alias": "thyEntryCollapsible"; "required": false; "isSignal": true; }; "thySortCardsInEntry": { "alias": "thySortCardsInEntry"; "required": false; "isSignal": true; }; "thyCardDroppableZonesAction": { "alias": "thyCardDroppableZonesAction"; "required": false; "isSignal": true; }; "thyCardDraggablePredicate": { "alias": "thyCardDraggablePredicate"; "required": false; "isSignal": true; }; "thyCardDropEnterPredicate": { "alias": "thyCardDropEnterPredicate"; "required": false; "isSignal": true; }; "thyCardDropAction": { "alias": "thyCardDropAction"; "required": false; "isSignal": true; }; }, { "thyVirtualScrolledIndexChange": "thyVirtualScrolledIndexChange"; "thyExpandLane": "thyExpandLane"; "thyExpandAllLanes": "thyExpandAllLanes"; "thyExpandEntry": "thyExpandEntry"; "thyCardDragStart": "thyCardDragStart"; }, ["cardTemplateRef", "laneTemplateRef", "headerTemplateRef", "entryTopTemplateRef", "entryBottomTemplateRef"], never, true, [{ directive: typeof i1.CdkScrollable; inputs: {}; outputs: {}; }]>;
}

declare class EntryItemSizeAverager extends ItemSizeAverager {
    private averageItemSize;
    defaultItemSize: number;
    constructor(defaultItemSize?: number);
    setAverageItemSize(value: number): number;
    getAverageItemSize(): number;
    reset(): void;
}
declare class ThyBoardEntryVirtualScrollStrategy extends AutoSizeVirtualScrollStrategy {
    averager: EntryItemSizeAverager;
    private readonly _scrolledIndexChange;
    /** @docs-private Implemented as part of VirtualScrollStrategy. */
    scrolledIndexChange: Observable<number>;
    entrySpacer: WritableSignal<number>;
    private cardsHeightMap;
    constructor(minBufferPx: number, maxBufferPx: number, averager?: EntryItemSizeAverager);
    /** @docs-private Implemented as part of VirtualScrollStrategy. */
    onDataLengthChanged(): void;
    /** @docs-private Implemented as part of VirtualScrollStrategy. */
    onContentRendered(): void;
    onContentScrolled(): void;
    checkEntrySpacer(): void;
    private getTotalContentSize;
    private updateTotalContentSize;
    updateCards(cards: ThyBoardCard[]): void;
    private getCardHeight;
    updateCardsHeight(): void;
    detach(): void;
}
declare function entryVirtualScrollStrategyFactory(autoSizeDir: ThyBoardEntryVirtualScroll): ThyBoardEntryVirtualScrollStrategy;
declare class ThyBoardEntryVirtualScroll extends CdkAutoSizeVirtualScroll implements OnInit, OnChanges {
    _minBufferPx: number;
    set minBufferPx(value: number);
    get minBufferPx(): number;
    _maxBufferPx: number;
    set maxBufferPx(value: number);
    get maxBufferPx(): number;
    defaultCardSize: number;
    cards: _angular_core.InputSignal<ThyBoardCard[]>;
    renderCardComponents: _angular_core.Signal<readonly unknown[]>;
    readonly scrollStrategy: ThyBoardEntryVirtualScrollStrategy;
    constructor();
    ngOnInit(): void;
    ngOnChanges(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThyBoardEntryVirtualScroll, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ThyBoardEntryVirtualScroll, "cdk-virtual-scroll-viewport[entry]", never, { "minBufferPx": { "alias": "minBufferPx"; "required": true; }; "maxBufferPx": { "alias": "maxBufferPx"; "required": true; }; "defaultCardSize": { "alias": "defaultCardSize"; "required": false; }; "cards": { "alias": "cards"; "required": true; "isSignal": true; }; }, {}, ["renderCardComponents"], never, true, never>;
    static ngAcceptInputType_minBufferPx: unknown;
    static ngAcceptInputType_maxBufferPx: unknown;
    static ngAcceptInputType_defaultCardSize: unknown;
}

declare abstract class ThyBoardEntryDragDrop {
    boardEntry: ThyBoardEntryAbstract;
    currentViewport: _angular_core.Signal<CdkVirtualScrollViewport | undefined>;
    cdkDropLists: _angular_core.Signal<readonly CdkDropList<any>[]>;
    changeDetectorRef: ChangeDetectorRef;
    private preDraggingCard;
    private preCdkDropLists;
    constructor(boardEntry: ThyBoardEntryAbstract);
    cdkDragStarted(event: CdkDragStart): void;
    dragReleased(): void;
    checkCardDroppable(drag: CdkDrag<ThyBoardCard>, container: ThyBoardDragContainer): boolean;
    private checkCardDropInLaneAndEntry;
    dropListEnterPredicate: (drag: CdkDrag<ThyBoardCard>, drop: CdkDropList<ThyBoardDragContainer>) => boolean;
    drop(event: CdkDragDrop<ThyBoardDragContainer | SafeAny>): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThyBoardEntryDragDrop, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ThyBoardEntryDragDrop, never, never, {}, {}, never, never, true, never>;
}

declare abstract class ThyBoardEntryBase extends ThyBoardEntryDragDrop {
    boardEntry: ThyBoardEntryAbstract;
    renderer: Renderer2;
    elementRef: ElementRef<any>;
    sharedResizeObserver: SharedResizeObserver;
    ngZone: NgZone;
    entryVirtualScroll: _angular_core.Signal<ThyBoardEntryVirtualScroll | undefined>;
    entryBody: _angular_core.Signal<ElementRef<any> | undefined>;
    bottom: _angular_core.Signal<ElementRef<any> | undefined>;
    top: _angular_core.Signal<ElementRef<any> | undefined>;
    entrySplitTitle: _angular_core.Signal<ElementRef<any> | undefined>;
    status: _angular_core.InputSignal<ThyBoardEntryStatus | undefined>;
    cards: _angular_core.Signal<ThyBoardCard[] | undefined>;
    entryBodyHeight: number;
    entryDroppableZonesHeight: number;
    entryRealHeight: WritableSignal<number>;
    boardEntryStatus: typeof ThyBoardEntryStatus;
    private takeUntilDestroyed;
    constructor(boardEntry: ThyBoardEntryAbstract);
    setBodyHeight(): void;
    private getCardStatus;
    _getRealHeight(): any;
    scrolledIndexChange(event: number): void;
    scrollToOffset(payload: {
        position: 'top' | 'middle' | 'bottom';
        scrollTop: number;
        laneHight: number;
    }): void;
    trackByFn(index: number, item: ThyBoardCard): string | number;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThyBoardEntryBase, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ThyBoardEntryBase, never, never, { "status": { "alias": "status"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class ThyBoardEntryComponent {
    entryComponent: _angular_core.Signal<readonly ThyBoardEntryBase[]>;
    entry: _angular_core.InputSignal<ThyBoardEntry>;
    entries: _angular_core.InputSignal<ThyBoardEntry[]>;
    hasLane: _angular_core.InputSignalWithTransform<boolean, unknown>;
    lane: _angular_core.InputSignal<ThyBoardLane | undefined>;
    laneHeight: _angular_core.InputSignalWithTransform<number, unknown>;
    virtualScroll: _angular_core.InputSignalWithTransform<boolean, unknown>;
    cardTemplateRef: _angular_core.InputSignal<TemplateRef<any> | undefined>;
    container: _angular_core.InputSignal<HTMLElement>;
    defaultCardSize: _angular_core.InputSignalWithTransform<number, unknown>;
    draggingCard: _angular_core.InputSignal<CdkDrag<ThyBoardCard> | undefined>;
    hasDroppableZones: _angular_core.InputSignal<boolean | undefined>;
    /**
     * 获取卡片可放置的区域
     */
    cardDroppableZones: _angular_core.InputSignal<{
        laneId?: string;
        entryId: string;
        droppableZones: ThyBoardZone[];
    }[] | undefined>;
    topTemplateRef: _angular_core.InputSignal<TemplateRef<any> | undefined>;
    bottomTemplateRef: _angular_core.InputSignal<TemplateRef<any> | undefined>;
    /**
     * 是否支持排序,开启后支持同栏排序
     * @default false
     * @type boolean
     */
    sortable: _angular_core.InputSignal<ThyBoardDragScopeType | undefined>;
    /**
     * 是否支持拖动，变更栏和泳道
     * @default false
     * @type boolean
     */
    movable: _angular_core.InputSignal<ThyBoardDragScopeType | undefined>;
    cardDraggablePredicate: _angular_core.InputSignal<((event: ThyBoardDragPredicateEvent) => boolean) | undefined>;
    cardDropEnterPredicate: _angular_core.InputSignal<((event: ThyBoardDragPredicateEvent) => boolean) | undefined>;
    cardDropAction: _angular_core.InputSignal<((event: ThyBoardDropActionEvent) => Observable<boolean>) | undefined>;
    cardDragStarted: _angular_core.OutputEmitterRef<CdkDrag<ThyBoardCard>>;
    virtualScrolledIndexChange: _angular_core.OutputEmitterRef<ThyBoardVirtualScrolledIndexChangeEvent>;
    boardEntryStatus: typeof ThyBoardEntryStatus;
    entryIsExceedWipLimit: boolean;
    constructor();
    scrollToOffset(payload: {
        position: 'top' | 'middle' | 'bottom';
        scrollTop: number;
        laneHight: number;
    }): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThyBoardEntryComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThyBoardEntryComponent, "thy-board-entry", never, { "entry": { "alias": "entry"; "required": true; "isSignal": true; }; "entries": { "alias": "entries"; "required": true; "isSignal": true; }; "hasLane": { "alias": "hasLane"; "required": false; "isSignal": true; }; "lane": { "alias": "lane"; "required": false; "isSignal": true; }; "laneHeight": { "alias": "laneHeight"; "required": false; "isSignal": true; }; "virtualScroll": { "alias": "virtualScroll"; "required": false; "isSignal": true; }; "cardTemplateRef": { "alias": "cardTemplateRef"; "required": false; "isSignal": true; }; "container": { "alias": "container"; "required": true; "isSignal": true; }; "defaultCardSize": { "alias": "defaultCardSize"; "required": false; "isSignal": true; }; "draggingCard": { "alias": "draggingCard"; "required": false; "isSignal": true; }; "hasDroppableZones": { "alias": "hasDroppableZones"; "required": false; "isSignal": true; }; "cardDroppableZones": { "alias": "cardDroppableZones"; "required": false; "isSignal": true; }; "topTemplateRef": { "alias": "topTemplateRef"; "required": false; "isSignal": true; }; "bottomTemplateRef": { "alias": "bottomTemplateRef"; "required": false; "isSignal": true; }; "sortable": { "alias": "sortable"; "required": false; "isSignal": true; }; "movable": { "alias": "movable"; "required": false; "isSignal": true; }; "cardDraggablePredicate": { "alias": "cardDraggablePredicate"; "required": false; "isSignal": true; }; "cardDropEnterPredicate": { "alias": "cardDropEnterPredicate"; "required": false; "isSignal": true; }; "cardDropAction": { "alias": "cardDropAction"; "required": false; "isSignal": true; }; }, { "cardDragStarted": "cardDragStarted"; "virtualScrolledIndexChange": "virtualScrolledIndexChange"; }, never, never, true, never>;
}

declare class ThyBoardLaneComponent implements OnInit {
    locale: _angular_core.Signal<_tethys_pro_i18n.ThyI18nTranslation>;
    entryComponents: _angular_core.Signal<readonly ThyBoardEntryComponent[]>;
    isBatchOperation: boolean;
    swimlaneLength: number;
    laneHeight: number;
    lane: _angular_core.InputSignal<ThyBoardLane | undefined>;
    entries: _angular_core.InputSignal<ThyBoardEntry[]>;
    allLanesExpanded: _angular_core.InputSignal<boolean>;
    hasLane: _angular_core.InputSignalWithTransform<boolean, unknown>;
    virtualScroll: _angular_core.InputSignalWithTransform<boolean, unknown>;
    laneTemplateRef: _angular_core.InputSignal<TemplateRef<any> | undefined>;
    cardTemplateRef: _angular_core.InputSignal<TemplateRef<any>>;
    container: _angular_core.InputSignal<HTMLDivElement>;
    entryTopTemplateRef: _angular_core.InputSignal<TemplateRef<any> | undefined>;
    entryBottomTemplateRef: _angular_core.InputSignal<TemplateRef<any> | undefined>;
    defaultCardSize: _angular_core.InputSignalWithTransform<number, unknown>;
    /**
     * 是否支持栏的收起展开
     * @default false
     * @type boolean
     */
    laneCollapsible: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * 是否支持排序,开启后支持同栏排序
     * @default false
     * @type boolean
     */
    sortable: _angular_core.InputSignal<ThyBoardDragScopeType | undefined>;
    /**
     * 是否支持拖动，变更栏和泳道
     * @default false
     * @type boolean
     */
    movable: _angular_core.InputSignal<ThyBoardDragScopeType | undefined>;
    draggingCard: _angular_core.InputSignal<CdkDrag<ThyBoardCard> | undefined>;
    hasDroppableZones: _angular_core.InputSignal<boolean | undefined>;
    /**
     * 获取卡片可放置的区域
     */
    cardDroppableZones: _angular_core.InputSignal<{
        laneId?: string;
        entryId: string;
        droppableZones: ThyBoardZone[];
    }[] | undefined>;
    cardDraggablePredicate: _angular_core.InputSignal<((event: ThyBoardDragPredicateEvent) => boolean) | undefined>;
    cardDropEnterPredicate: _angular_core.InputSignal<((event: ThyBoardDragPredicateEvent) => boolean) | undefined>;
    cardDropAction: _angular_core.InputSignal<((event: ThyBoardDropActionEvent) => Observable<boolean>) | undefined>;
    cardDragStarted: _angular_core.OutputEmitterRef<CdkDrag<ThyBoardCard>>;
    /**
     * 展开收起泳道事件
     */
    expandLane: _angular_core.OutputEmitterRef<{
        lane: ThyBoardLane;
        expanded: boolean;
    }>;
    virtualScrolledIndexChange: _angular_core.OutputEmitterRef<ThyBoardVirtualScrolledIndexChangeEvent>;
    constructor();
    ngOnInit(): void;
    private setLaneHeight;
    expand(): void;
    dropListDropped: (event: ThyBoardDropActionEvent) => Observable<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThyBoardLaneComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThyBoardLaneComponent, "thy-board-lane", never, { "lane": { "alias": "lane"; "required": false; "isSignal": true; }; "entries": { "alias": "entries"; "required": true; "isSignal": true; }; "allLanesExpanded": { "alias": "allLanesExpanded"; "required": false; "isSignal": true; }; "hasLane": { "alias": "hasLane"; "required": false; "isSignal": true; }; "virtualScroll": { "alias": "virtualScroll"; "required": false; "isSignal": true; }; "laneTemplateRef": { "alias": "laneTemplateRef"; "required": false; "isSignal": true; }; "cardTemplateRef": { "alias": "cardTemplateRef"; "required": true; "isSignal": true; }; "container": { "alias": "container"; "required": true; "isSignal": true; }; "entryTopTemplateRef": { "alias": "entryTopTemplateRef"; "required": false; "isSignal": true; }; "entryBottomTemplateRef": { "alias": "entryBottomTemplateRef"; "required": false; "isSignal": true; }; "defaultCardSize": { "alias": "defaultCardSize"; "required": false; "isSignal": true; }; "laneCollapsible": { "alias": "laneCollapsible"; "required": false; "isSignal": true; }; "sortable": { "alias": "sortable"; "required": false; "isSignal": true; }; "movable": { "alias": "movable"; "required": false; "isSignal": true; }; "draggingCard": { "alias": "draggingCard"; "required": false; "isSignal": true; }; "hasDroppableZones": { "alias": "hasDroppableZones"; "required": false; "isSignal": true; }; "cardDroppableZones": { "alias": "cardDroppableZones"; "required": false; "isSignal": true; }; "cardDraggablePredicate": { "alias": "cardDraggablePredicate"; "required": false; "isSignal": true; }; "cardDropEnterPredicate": { "alias": "cardDropEnterPredicate"; "required": false; "isSignal": true; }; "cardDropAction": { "alias": "cardDropAction"; "required": false; "isSignal": true; }; }, { "cardDragStarted": "cardDragStarted"; "expandLane": "expandLane"; "virtualScrolledIndexChange": "virtualScrolledIndexChange"; }, never, never, true, never>;
}

declare class ThyBoardBodyScrollableDirective extends CdkScrollable implements AfterViewInit {
    lanes: QueryList<ThyBoardLaneComponent>;
    /**
     * 是否禁用自定义滚动
     * @default false
     * @type boolean
     */
    readonly thyBoardBodyScrollable: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * 泳道列表
     * @default []
     * @type ThyBoardLane[]
     */
    thyLanes: _angular_core.InputSignal<ThyBoardLane[]>;
    private takeUntilDestroyed;
    ngAfterViewInit(): void;
    private laneIsInViewport;
    private buildLanesMapById;
    private laneScrollToOffset;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThyBoardBodyScrollableDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ThyBoardBodyScrollableDirective, "[thy-board-body-scrollable], [thyBoardBodyScrollable]", never, { "thyBoardBodyScrollable": { "alias": "thyBoardBodyScrollable"; "required": false; "isSignal": true; }; "thyLanes": { "alias": "thyLanes"; "required": false; "isSignal": true; }; }, {}, ["lanes"], never, true, never>;
}

declare class ThyBoardSortableEntryComponent extends ThyBoardEntryBase {
    boardEntry: ThyBoardEntryAbstract;
    locale: _angular_core.Signal<_tethys_pro_i18n.ThyI18nTranslation>;
    constructor(boardEntry: ThyBoardEntryAbstract);
    checkCardDroppable(drag: CdkDrag<ThyBoardCard>, container: ThyBoardDragContainer): boolean;
    drop(event: CdkDragDrop<ThyBoardDragContainer | SafeAny>): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThyBoardSortableEntryComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThyBoardSortableEntryComponent, "thy-board-sortable-entry", never, {}, {}, never, never, true, never>;
}

declare class ThyBoardMovableEntryComponent extends ThyBoardEntryBase {
    boardEntry: ThyBoardEntryAbstract;
    locale: _angular_core.Signal<_tethys_pro_i18n.ThyI18nTranslation>;
    isDraggingList: boolean;
    showBackDropWhenDragging: _angular_core.Signal<boolean>;
    cardDroppableZone: _angular_core.Signal<_tethys_pro_board.ThyBoardZone[] | null>;
    dropReady: _angular_core.Signal<boolean>;
    constructor(boardEntry: ThyBoardEntryAbstract);
    cdkDragStarted(event: CdkDragStart): void;
    checkCardDroppable(drag: CdkDrag<ThyBoardCard>, container: ThyBoardDragContainer): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThyBoardMovableEntryComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThyBoardMovableEntryComponent, "thy-board-movable-entry", never, {}, {}, never, never, true, never>;
}

declare class ThyBoardHeaderComponent implements OnInit {
    locale: _angular_core.Signal<_tethys_pro_i18n.ThyI18nTranslation>;
    entries: _angular_core.InputSignal<ThyBoardEntry[]>;
    hasLane: _angular_core.InputSignalWithTransform<boolean, unknown>;
    readonly allLanesExpanded: _angular_core.ModelSignal<boolean>;
    headerTemplateRef: _angular_core.InputSignal<TemplateRef<any> | undefined>;
    /**
     * 是否支持栏的收起展开
     * @default false
     * @type boolean
     */
    entryCollapsible: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * 是否有栏已收起
     * @default false
     * @type boolean
     */
    hasCollapsedEntry: _angular_core.InputSignalWithTransform<boolean, unknown>;
    container: _angular_core.InputSignal<ElementRef<any>>;
    expandAllLanes: _angular_core.OutputEmitterRef<boolean>;
    /**
     * 展开收起栏事件
     */
    expandEntry: _angular_core.OutputEmitterRef<{
        entry: ThyBoardEntry;
        expanded: boolean;
    }>;
    isFullscreen: boolean;
    containerClientHeight: _angular_core.Signal<any>;
    constructor();
    ngOnInit(): void;
    expandAllLane(): void;
    expandBoardEntry(event: ThyBoardEntry): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThyBoardHeaderComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThyBoardHeaderComponent, "thy-board-header", never, { "entries": { "alias": "entries"; "required": true; "isSignal": true; }; "hasLane": { "alias": "hasLane"; "required": false; "isSignal": true; }; "allLanesExpanded": { "alias": "allLanesExpanded"; "required": false; "isSignal": true; }; "headerTemplateRef": { "alias": "headerTemplateRef"; "required": false; "isSignal": true; }; "entryCollapsible": { "alias": "entryCollapsible"; "required": false; "isSignal": true; }; "hasCollapsedEntry": { "alias": "hasCollapsedEntry"; "required": false; "isSignal": true; }; "container": { "alias": "container"; "required": true; "isSignal": true; }; }, { "allLanesExpanded": "allLanesExpandedChange"; "expandAllLanes": "expandAllLanes"; "expandEntry": "expandEntry"; }, never, never, true, never>;
}

declare class ThyBoardFuncPipe implements PipeTransform {
    transform(card: ThyBoardCard, fn: ((event: ThyBoardDragPredicateEvent) => boolean) | undefined, container: ThyBoardDragContainer): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThyBoardFuncPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<ThyBoardFuncPipe, "thyBoardFunc", true>;
}

declare class ThyBoardSkeletonComponent {
    elementRef: ElementRef;
    hasLane: _angular_core.InputSignal<boolean | undefined>;
    entries: _angular_core.InputSignal<ThyBoardEntry[]>;
    constructor(elementRef: ElementRef);
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThyBoardSkeletonComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThyBoardSkeletonComponent, "thy-board-skeleton", never, { "hasLane": { "alias": "hasLane"; "required": false; "isSignal": true; }; "entries": { "alias": "entries"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class ThyProBoardModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThyProBoardModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<ThyProBoardModule, never, [typeof i1$1.ThyTooltipModule, typeof i2.ThyIconModule, typeof i3.ThyActionModule, typeof i4.ThySharedModule, typeof i5.CommonModule, typeof i1.CdkScrollableModule, typeof ThyBoardComponent, typeof ThyBoardBodyScrollableDirective, typeof ThyBoardLaneComponent, typeof ThyBoardEntryComponent, typeof ThyBoardSortableEntryComponent, typeof ThyBoardMovableEntryComponent, typeof ThyBoardHeaderComponent, typeof ThyBoardEntryVirtualScroll, typeof ThyBoardFuncPipe, typeof ThyBoardSkeletonComponent], [typeof ThyBoardComponent]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<ThyProBoardModule>;
}

declare const EMPTY_OBJECT_ID_STR = "000000000000000000000000";

/**
 * Original service that keeps track of all the drag item and drop container
 * instances, and manages global event listeners on the `document` in DragDropRegistry.
 * Now, When the scrollable is scrolled, the service need to emits the event
 * to drag item and drop container instances.
 */
declare class ThyDragDropRegistry<I extends {
    previewClass?: string | string[] | undefined;
    isDragging(): boolean;
} & DragRef, C> extends DragDropRegistry implements OnDestroy {
    private _scrollDispatcher;
    private ngZone;
    private _scrollSubscription;
    constructor(_ngZone: NgZone, _document: any, _scrollDispatcher: ScrollDispatcher);
    startDragging(drag: I, event: TouchEvent | MouseEvent): void;
    unsubscribeScrolled(): void;
    stopDragging(drag: I): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThyDragDropRegistry<any, any>, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ThyDragDropRegistry<any, any>>;
}

export { EMPTY_OBJECT_ID_STR, EntryItemSizeAverager, THY_BOARD_ENTRY, ThyBoardBodyScrollableDirective, ThyBoardComponent, ThyBoardDragScopeType, ThyBoardEntryBase, ThyBoardEntryComponent, ThyBoardEntryDragDrop, ThyBoardEntryStatus, ThyBoardEntryVirtualScroll, ThyBoardEntryVirtualScrollStrategy, ThyBoardFuncPipe, ThyBoardHeaderComponent, ThyBoardLaneComponent, ThyBoardMovableEntryComponent, ThyBoardService, ThyBoardSkeletonComponent, ThyBoardSortableEntryComponent, ThyDragDropRegistry, ThyProBoardModule, entryVirtualScrollStrategyFactory };
export type { ThyBoardCard, ThyBoardDragContainer, ThyBoardDragPredicateEvent, ThyBoardDragStartEvent, ThyBoardDropActionEvent, ThyBoardEntry, ThyBoardEntryAbstract, ThyBoardLane, ThyBoardSortEvent, ThyBoardVirtualScrolledIndexChangeEvent, ThyBoardZone };
//# sourceMappingURL=tethys-pro-board.d.ts.map