import * as i0 from '@angular/core';
import { Injector, InjectionToken, OnInit } from '@angular/core';
import * as i1 from '@angular/common';
import * as i3 from '@acorex/modules/calendar-management';
import * as i4 from '@acorex/platform/layout/widget-core';
import { AXPWidgetColumnNode, AXPLayoutBaseWidgetComponent, AXPWidgetConfig } from '@acorex/platform/layout/widget-core';
import { AXPEntity, AXPMenuProvider, AXPMenuProviderContext, AXPSearchCommandProvider, AXPSearchResult, AXPSettingDefinitionProvider, AXPSettingDefinitionProviderContext } from '@acorex/platform/common';
import { AXPEntityModel, AXMEntityCrudServiceImpl, AXPEntityDefinitionLoader, AXPEntityDefinitionPreloader, AXPEntityPreloadEntity } from '@acorex/platform/layout/entity';
import { AXMSecurityManagementUsersEntityModel } from '@acorex/modules/security-management';
import { AXRange, AXStyleColorType, AXClickEvent } from '@acorex/cdk/common';
import { AXSchedulerResource, AXSchedulerDateRange } from '@acorex/components/scheduler';
import { AXPUserReference, AXPActionMenuItem, AXPExecuteCommand, AXPExecuteCommandResult, AXPDataSourceDefinitionProvider, AXPDataSourceDefinition } from '@acorex/platform/core';
import { AXContextMenuItemsClickEvent, AXContextMenuOpeningEvent } from '@acorex/components/menu';
import { AXHolidayDate } from '@acorex/core/date-time';
import { Subject } from 'rxjs';

declare class AXPTaskBoardModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPTaskBoardModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AXPTaskBoardModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AXPTaskBoardModule>;
}

declare class AXMTaskTypeEntityModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMTaskTypeEntityModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AXMTaskTypeEntityModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AXMTaskTypeEntityModule>;
}

declare class AXMTaskStatusEntityModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMTaskStatusEntityModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AXMTaskStatusEntityModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AXMTaskStatusEntityModule>;
}

declare class AXMTaskEntityModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMTaskEntityModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AXMTaskEntityModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AXMTaskEntityModule>;
}

declare class AXMTaskChecklistItemEntityModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMTaskChecklistItemEntityModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AXMTaskChecklistItemEntityModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AXMTaskChecklistItemEntityModule>;
}

declare class AXMTaskAssignmentEntityModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMTaskAssignmentEntityModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AXMTaskAssignmentEntityModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AXMTaskAssignmentEntityModule>;
}

declare class AXMTimeLogEntityModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMTimeLogEntityModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AXMTimeLogEntityModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AXMTimeLogEntityModule>;
}

declare class AXMTaskDependencyEntityModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMTaskDependencyEntityModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AXMTaskDependencyEntityModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AXMTaskDependencyEntityModule>;
}

declare class AXMTaskContextEntityModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMTaskContextEntityModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AXMTaskContextEntityModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AXMTaskContextEntityModule>;
}

declare class AXMTaskTemplateEntityModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMTaskTemplateEntityModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AXMTaskTemplateEntityModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AXMTaskTemplateEntityModule>;
}

declare class AXMTaskManagementModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMTaskManagementModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AXMTaskManagementModule, never, [typeof i1.CommonModule, typeof AXPTaskBoardModule, typeof i3.AXMCalendarManagementModule, typeof i4.AXPWidgetCoreModule, typeof AXMTaskTypeEntityModule, typeof AXMTaskStatusEntityModule, typeof AXMTaskEntityModule, typeof AXMTaskChecklistItemEntityModule, typeof AXMTaskAssignmentEntityModule, typeof AXMTimeLogEntityModule, typeof AXMTaskDependencyEntityModule, typeof AXMTaskContextEntityModule, typeof AXMTaskTemplateEntityModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AXMTaskManagementModule>;
}

declare const RootConfig: {
    config: {
        i18n: string;
        module: string;
    };
    module: {
        name: string;
        title: string;
        icon: string;
    };
    entities: {
        taskType: {
            name: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
        taskStatus: {
            name: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
        task: {
            name: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
        taskChecklistItem: {
            name: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
        taskAssignment: {
            name: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
        timeLog: {
            name: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
        taskDependency: {
            name: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
        taskContext: {
            name: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
        taskTemplate: {
            name: string;
            title: string;
            titlePlural: string;
            icon: string;
        };
    };
};

declare function taskTypeFactory(injector: Injector): Promise<AXPEntity | null>;

interface AXMTaskManagementTaskTypeEntityModel extends AXPEntityModel<string> {
    name: string;
    title: string;
    description?: string;
    icon?: string;
    color?: string;
    isActive: boolean;
    allowedContextTypes?: string[];
    formTemplateId?: string;
    defaultStatusId?: string;
    hasChecklist: boolean;
    hasTimeTracking: boolean;
    hasAttachments: boolean;
    hasDependencies: boolean;
    hasSubtasks: boolean;
}

declare abstract class AXMTaskTypeService extends AXMEntityCrudServiceImpl<string, AXMTaskManagementTaskTypeEntityModel> {
}
declare class AXMTaskTypeServiceImpl extends AXMTaskTypeService {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMTaskTypeServiceImpl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXMTaskTypeServiceImpl>;
}

declare function taskStatusFactory(injector: Injector): Promise<AXPEntity | null>;

interface AXMTaskManagementTaskStatusEntityModel extends AXPEntityModel<string> {
    taskTypeId: string;
    name: string;
    title: string;
    description?: string;
    color: string;
    icon?: string;
    isDefault: boolean;
    isFinal: boolean;
    order: number;
    allowedTransitions: string[];
    isActive: boolean;
}

declare abstract class AXMTaskStatusService extends AXMEntityCrudServiceImpl<string, AXMTaskManagementTaskStatusEntityModel> {
}
declare class AXMTaskStatusServiceImpl extends AXMTaskStatusService {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMTaskStatusServiceImpl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXMTaskStatusServiceImpl>;
}

declare function taskFactory(injector: Injector): Promise<AXPEntity | null>;

interface AXMTaskManagementTaskEntityModel extends AXPEntityModel<string> {
    title: string;
    description?: string;
    taskTypeId: string;
    statusId: string;
    priority: 'low' | 'medium' | 'high' | 'critical';
    dueDate?: Date;
    startDate?: Date;
    completedDate?: Date;
    estimatedHours?: number;
    actualHours?: number;
    progress: number;
    order: number;
    tags?: string[];
    isArchived: boolean;
    contextType?: string;
    contextId?: string;
    parentTaskId?: string;
    formTemplateId?: string;
    dynamicFields?: Record<string, any>;
}

declare abstract class AXMTaskService extends AXMEntityCrudServiceImpl<string, AXMTaskManagementTaskEntityModel> {
}
declare class AXMTaskServiceImpl extends AXMTaskService {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMTaskServiceImpl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXMTaskServiceImpl>;
}

declare function taskChecklistItemFactory(injector: Injector): Promise<AXPEntity | null>;

interface AXMTaskManagementTaskChecklistItemEntityModel extends AXPEntityModel<string> {
    taskId: string;
    title: string;
    description?: string;
    isCompleted: boolean;
    completedBy?: string;
    completedAt?: Date;
    order: number;
    dueDate?: Date;
    assignedTo?: string;
}

declare abstract class AXMTaskChecklistItemService extends AXMEntityCrudServiceImpl<string, AXMTaskManagementTaskChecklistItemEntityModel> {
}
declare class AXMTaskChecklistItemServiceImpl extends AXMTaskChecklistItemService {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMTaskChecklistItemServiceImpl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXMTaskChecklistItemServiceImpl>;
}

declare function taskAssignmentFactory(injector: Injector): Promise<AXPEntity | null>;

interface AXMTaskManagementTaskAssignmentEntityModel extends AXPEntityModel<string> {
    taskId: string;
    userId: string;
    role?: string;
    assignedBy: string;
    assignedAt: Date;
    isActive: boolean;
}

declare abstract class AXMTaskAssignmentService extends AXMEntityCrudServiceImpl<string, AXMTaskManagementTaskAssignmentEntityModel> {
}
declare class AXMTaskAssignmentServiceImpl extends AXMTaskAssignmentService {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMTaskAssignmentServiceImpl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXMTaskAssignmentServiceImpl>;
}

declare function timeLogFactory(injector: Injector): Promise<AXPEntity | null>;

interface AXMTaskManagementTimeLogEntityModel extends AXPEntityModel<string> {
    taskId: string;
    userId: string;
    startTime: Date;
    endTime?: Date;
    duration: number;
    description?: string;
    billableHours?: number;
    rate?: number;
    isApproved: boolean;
    approvedBy?: string;
    approvedAt?: Date;
}

declare abstract class AXMTimeLogService extends AXMEntityCrudServiceImpl<string, AXMTaskManagementTimeLogEntityModel> {
}
declare class AXMTimeLogServiceImpl extends AXMTimeLogService {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMTimeLogServiceImpl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXMTimeLogServiceImpl>;
}

declare function taskDependencyFactory(injector: Injector): Promise<AXPEntity | null>;

interface AXMTaskManagementTaskDependencyEntityModel extends AXPEntityModel<string> {
    taskId: string;
    dependsOnTaskId: string;
    dependencyType: 'finish-to-start' | 'start-to-start' | 'finish-to-finish' | 'start-to-finish';
    lagDays?: number;
    isActive: boolean;
    createdBy: string;
}

declare abstract class AXMTaskDependencyService extends AXMEntityCrudServiceImpl<string, AXMTaskManagementTaskDependencyEntityModel> {
}
declare class AXMTaskDependencyServiceImpl extends AXMTaskDependencyService {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMTaskDependencyServiceImpl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXMTaskDependencyServiceImpl>;
}

declare function taskContextFactory(injector: Injector): Promise<AXPEntity | null>;

interface AXMTaskManagementTaskContextEntityModel extends AXPEntityModel<string> {
    taskId: string;
    contextType: string;
    contextId: string;
    contextTitle?: string;
    isPrimary: boolean;
}

declare abstract class AXMTaskContextService extends AXMEntityCrudServiceImpl<string, AXMTaskManagementTaskContextEntityModel> {
}
declare class AXMTaskContextServiceImpl extends AXMTaskContextService {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMTaskContextServiceImpl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXMTaskContextServiceImpl>;
}

declare function taskTemplateFactory(injector: Injector): Promise<AXPEntity | null>;

interface AXMTaskManagementTaskTemplateEntityModel extends AXPEntityModel<string> {
    name: string;
    title: string;
    description?: string;
    taskTypeId: string;
    templateData: {
        title: string;
        description?: string;
        estimatedHours?: number;
        priority: string;
        tags: string[];
        checklistItems: Array<{
            title: string;
            description?: string;
            order: number;
        }>;
        dynamicFields?: Record<string, any>;
    };
    isPublic: boolean;
    createdBy: string;
}

declare abstract class AXMTaskTemplateService extends AXMEntityCrudServiceImpl<string, AXMTaskManagementTaskTemplateEntityModel> {
}
declare class AXMTaskTemplateServiceImpl extends AXMTaskTemplateService {
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMTaskTemplateServiceImpl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXMTaskTemplateServiceImpl>;
}

declare class AXMTaskManagementEntityProvider implements AXPEntityDefinitionLoader, AXPEntityDefinitionPreloader {
    private injector;
    preload(): AXPEntityPreloadEntity[];
    get(moduleName: string, entityName: string): Promise<AXPEntity | null>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXMTaskManagementEntityProvider, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXMTaskManagementEntityProvider>;
}

declare class AXMTaskManagementMenuProvider implements AXPMenuProvider {
    private entityService;
    provide(context: AXPMenuProviderContext): Promise<void>;
}

declare class AXMSearchCommandProvider extends AXPSearchCommandProvider {
    commands: AXPSearchResult[];
}

declare class AXMSettingProvider implements AXPSettingDefinitionProvider {
    provide(context: AXPSettingDefinitionProviderContext): Promise<void>;
}

interface AXPAuditable {
    createdAt?: Date;
    updatedAt?: Date;
    createdBy?: string;
    updatedBy?: string;
}
/**
 * Defines the structure of an extra field for a task.
 */
interface AXPExtraField {
    title: string;
    description?: string;
    widget: AXPWidgetColumnNode;
}
/**
 * Represents a single task in the system.
 * @template T - The type of custom data associated with the task.
 */
interface AXPTask<T = Record<string, any>> extends AXPAuditable {
    /**
     * Unique identifier for the task. Should be immutable.
     */
    readonly id: string | number;
    /**
     * The index of the task.
     */
    index: number;
    /**
     * The title of the task.
     */
    title: string;
    /**
     * A detailed description of the task, potentially supporting markdown.
     */
    description?: string;
    /**
     * The current status of the task.
     */
    status: {
        id: string | number;
        title: string;
    };
    /**
     * The user who is assigned to work on the task.
     */
    assignee?: AXPUserReference;
    /**
     * The user who created or reported the task.
     */
    reporter: AXPUserReference;
    /**
     * Other users involved or watching the task.
     */
    participants?: AXPUserReference[];
    /**
     * The start date of the task.
     */
    startDate: Date;
    /**
     * The end date or deadline of the task.
     */
    endDate: Date;
    /**
     * The priority level of the task.
     */
    priority?: 'highest' | 'high' | 'medium' | 'low' | 'lowest';
    /**
     * The progress of the task, from 0 to 100.
     */
    progress?: number;
    /**
     * An array of tags for categorizing and filtering.
     */
    tags?: string[];
    /**
     * Indicates if the task is an all-day event.
     */
    allDay?: boolean;
    /**
     * A CSS class to apply to the task for custom styling.
     */
    cssClass?: string;
    /**
     * Indicates if the task is read-only for the current user.
     */
    readonly?: boolean;
    /**
     * Custom data associated with the task for extensibility.
     */
    data?: T;
    /**
     * The name of the provider that owns this task.
     */
    provider?: string;
    /**
     * The resource id associated with the task.
     */
    resourceId?: string | number;
}
/**
 * Defines the filter options for querying tasks.
 */
interface AXPTaskFilter {
    range?: AXRange<Date>;
    assigneeIds?: (string | number)[];
    reporterIds?: (string | number)[];
    tags?: string[];
    types?: string[];
    skip?: number;
    take?: number;
    priorities?: Array<'highest' | 'high' | 'medium' | 'low' | 'lowest' | 'no_priority'>;
}
/**
 * Represents an action performed on a task.
 */
interface AXPTaskAction {
    nativeEvent: MouseEvent;
    task: AXPTask;
}
/**
 * Represents the status of a task (e.g., a column on a Kanban board).
 */
interface AXPTaskStatus {
    key: string;
    index: number;
    title: string;
    color?: string;
}
interface AXPResource extends AXSchedulerResource {
    readonly id: string | number;
    title: string;
    description?: string;
}
/**
 * An abstract class for a workflow task provider, which is responsible for
 * fetching and manipulating task data from a specific source.
 * @template T - The type of custom data associated with the tasks.
 */
declare abstract class AXPWorkflowTaskProvider<T = Record<string, any>> {
    abstract get name(): string;
    abstract get title(): string;
    abstract get icon(): string;
    /**
     * Retrieves a list of tasks based on the provided filter options.
     * @param options - The filter options.
     * @returns A promise that resolves with the list of tasks and the total count.
     */
    abstract getTasks(options?: AXPTaskFilter): Promise<{
        items: AXPTask<T>[];
        total: number;
    }>;
    /**
     * Returns a list of extra fields that can be displayed as columns for this provider's tasks.
     * This defines the schema for custom data.
     */
    abstract getExtraFields(): Promise<AXPExtraField[]>;
    abstract getActions(context?: AXPTask<T>): Promise<AXPActionMenuItem[]>;
    abstract getStatuses(): Promise<AXPTaskStatus[]>;
    getResources(): Promise<AXPResource[]>;
    /**
     * Updates a list of tasks.
     * @param tasks - The tasks to update.
     * @returns A promise that resolves with the updated tasks.
     */
    abstract updateTasks(tasks: AXPTask<T>[]): Promise<AXPTask<T>[]>;
    /**
     * Executes a command on the task provider.
     * @param command - The command to execute.
     * @returns A promise that resolves with the result of the command execution.
     */
    abstract executeCommand(command: AXPExecuteCommand): Promise<AXPExecuteCommandResult>;
}
/**
 * Injection token for registering multiple workflow task providers.
 */
declare const AXP_WORKFLOW_TASK_PROVIDER: InjectionToken<AXPWorkflowTaskProvider<Record<string, any>>[]>;

declare class AXPTaskBoardService {
    private calendarService;
    private calendarManagementService;
    private providers;
    refresh$: Subject<void>;
    getTaskTypes(): Promise<AXPWorkflowTaskProvider[]>;
    getTasks(options?: AXPTaskFilter): Promise<{
        items: AXPTask[];
        total: number;
    }>;
    updateTaskDateRange(task: AXPTask, range: AXSchedulerDateRange): Promise<AXPTask>;
    updateTasks(tasks: AXPTask[]): Promise<AXPTask[]>;
    executeCommand(command: AXPExecuteCommand, providerName: string): void;
    getStatusName(key: any, providerName: string): Promise<string | null>;
    getEvents(range: AXRange<Date>): Promise<AXHolidayDate[]>;
    getProvider(name: string | undefined): AXPWorkflowTaskProvider | null;
    rangeCalculator(type: string): AXRange<Date> | undefined;
    getResources(providerName: string): Promise<AXPResource[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPTaskBoardService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AXPTaskBoardService>;
}

type TaskPriority$1 = NonNullable<AXPTask['priority']>;
type PriorityFilterKey$1 = TaskPriority$1 | 'no_priority';
type Priority = {
    title: string;
    name: PriorityFilterKey$1;
};
type TaskType$1 = {
    name: string;
    title: string;
    icon: string;
};
type Assignee$1 = AXMSecurityManagementUsersEntityModel & {
    displayName: string;
};
type DateRange = {
    title: string;
    name: string;
};
type QueryParam = {
    type?: string[];
    dateRange: string;
    assignee?: string[];
    priority?: PriorityFilterKey$1[];
};
declare class AXPTaskBoardShortcutViewComponent extends AXPLayoutBaseWidgetComponent {
    #private;
    private readonly taskBoardService;
    protected tasksCount: i0.WritableSignal<number>;
    protected readonly assignee: i0.Signal<Assignee$1[]>;
    protected readonly priority: i0.Signal<Priority[]>;
    protected readonly selectedTaskTypes: i0.Signal<TaskType$1[]>;
    protected readonly dateRange: i0.Signal<DateRange>;
    protected readonly title: i0.Signal<string>;
    protected readonly queryParams: i0.Signal<QueryParam>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPTaskBoardShortcutViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AXPTaskBoardShortcutViewComponent, "ng-component", never, {}, {}, never, never, true, never>;
}

declare const AXPTaskBoardShortcut: AXPWidgetConfig;
declare module '@acorex/platform/layout/widget-core' {
    interface AXPWidgetTypesMap {
        taskBoard: 'task-board';
    }
}

type TaskPriority = NonNullable<AXPTask['priority']>;
type PriorityFilterKey = TaskPriority | 'no_priority';
type SortBy = {
    title: string;
    name: 'priority' | 'dueDate';
};
type TaskType = {
    name: string;
    title: string;
    icon: string;
};
type Assignee = AXMSecurityManagementUsersEntityModel & {
    displayName: string;
};
declare class AXPTaskBoardWidgetViewComponent extends AXPLayoutBaseWidgetComponent implements OnInit {
    #private;
    taskClick: i0.OutputEmitterRef<AXPTask<Record<string, any>>>;
    private readonly taskBoardService;
    private contextMenu;
    protected readonly maxItems: i0.Signal<number>;
    protected readonly assignee: i0.Signal<Assignee[]>;
    protected readonly selectedTaskTypes: i0.Signal<TaskType[]>;
    protected readonly sortBy: i0.Signal<SortBy>;
    private readonly allTasks;
    private currentTask;
    protected readonly selectedPriorities: i0.WritableSignal<Set<PriorityFilterKey>>;
    /**
     * Computes a list of tasks that are filtered, sorted, and limited.
     */
    protected readonly filteredTasks: i0.Signal<AXPTask<Record<string, any>>[]>;
    /**
     * Generates the data for the priority filter chips in the header.
     */
    protected readonly priorityBadges: i0.Signal<{
        name: PriorityFilterKey;
        label: string;
        count: number;
        color: AXStyleColorType;
    }[]>;
    /**
     * Compares two tasks based on their priority.
     */
    private compareByPriority;
    /**
     * Compares two tasks based on their due date.
     */
    private compareByDueDate;
    protected onPriorityFilterChange(priorityKey: PriorityFilterKey): void;
    protected onTaskClick(task: AXPTask): void;
    protected onMoreOptionsClick(task: AXPTask, event: AXClickEvent): void;
    protected handleContextMenuItemClick(event: AXContextMenuItemsClickEvent): void;
    protected handleContextMenuOnOpening(event: AXContextMenuOpeningEvent): Promise<void>;
    private getBadgeColorForPriority;
    private sortTasks;
    static ɵfac: i0.ɵɵFactoryDeclaration<AXPTaskBoardWidgetViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AXPTaskBoardWidgetViewComponent, "ng-component", never, {}, { "taskClick": "taskClick"; }, never, never, true, never>;
}

declare const AXPTaskBoardWidget: AXPWidgetConfig;
declare module '@acorex/platform/layout/widget-core' {
    interface AXPWidgetTypesMap {
        taskBoard: 'task-board';
    }
}

declare class AXPTaskTypeDataSourceDefinition implements AXPDataSourceDefinitionProvider {
    protected taskBoardService: AXPTaskBoardService;
    items(): Promise<AXPDataSourceDefinition[]>;
}

export { AXMSearchCommandProvider, AXMSettingProvider, AXMTaskAssignmentEntityModule, AXMTaskAssignmentService, AXMTaskAssignmentServiceImpl, AXMTaskChecklistItemEntityModule, AXMTaskChecklistItemService, AXMTaskChecklistItemServiceImpl, AXMTaskContextEntityModule, AXMTaskContextService, AXMTaskContextServiceImpl, AXMTaskDependencyEntityModule, AXMTaskDependencyService, AXMTaskDependencyServiceImpl, AXMTaskEntityModule, AXMTaskManagementEntityProvider, AXMTaskManagementMenuProvider, AXMTaskManagementModule, AXMTaskService, AXMTaskServiceImpl, AXMTaskStatusEntityModule, AXMTaskStatusService, AXMTaskStatusServiceImpl, AXMTaskTemplateEntityModule, AXMTaskTemplateService, AXMTaskTemplateServiceImpl, AXMTaskTypeEntityModule, AXMTaskTypeService, AXMTaskTypeServiceImpl, AXMTimeLogEntityModule, AXMTimeLogService, AXMTimeLogServiceImpl, AXPTaskBoardModule, AXPTaskBoardService, AXPTaskBoardShortcut, AXPTaskBoardShortcutViewComponent, AXPTaskBoardWidget, AXPTaskBoardWidgetViewComponent, AXPTaskTypeDataSourceDefinition, AXPWorkflowTaskProvider, AXP_WORKFLOW_TASK_PROVIDER, RootConfig, taskAssignmentFactory, taskChecklistItemFactory, taskContextFactory, taskDependencyFactory, taskFactory, taskStatusFactory, taskTemplateFactory, taskTypeFactory, timeLogFactory };
export type { AXMTaskManagementTaskAssignmentEntityModel, AXMTaskManagementTaskChecklistItemEntityModel, AXMTaskManagementTaskContextEntityModel, AXMTaskManagementTaskDependencyEntityModel, AXMTaskManagementTaskEntityModel, AXMTaskManagementTaskStatusEntityModel, AXMTaskManagementTaskTemplateEntityModel, AXMTaskManagementTaskTypeEntityModel, AXMTaskManagementTimeLogEntityModel, AXPExtraField, AXPResource, AXPTask, AXPTaskAction, AXPTaskFilter, AXPTaskStatus };
