@acorex-platform/module-task-management-client 0.0.21

package/types/acorex-platform-module-task-management-client.d.ts

@@ -0,0 +1,850 @@
+import * as _angular_core from '@angular/core';
+import { InputSignal, Type, InjectionToken, ElementRef } from '@angular/core';
+import * as i1$1 from '@angular/common';
+import * as i1 from '@acorex-platform/framework-client/runtime';
+import * as i3 from '@acorex-platform/module-calendar-management-client';
+import * as i4 from '@acorex-platform/framework-client/layout/widget-core';
+import { AXPLayoutBaseWidgetComponent } from '@acorex-platform/framework-client/layout/widget-core';
+import { AXPMenuProvider, AXPMenuProviderContext, AXPSearchCommandProvider, AXPSearchResult, AXPSettingDefinitionProvider, AXPSettingDefinitionProviderContext, AXPSettingsService } from '@acorex-platform/framework-client/common';
+import { AXMSecurityManagementUsersEntityModel } from '@acorex-platform/module-security-management-client/contracts';
+import { AXPUserReference, AXPActionMenuItem, AXPExecuteCommand, AXPWidgetNode, AXPDefinitionCategory } from '@acorex-platform/framework-shared/core';
+import { AXPWidgetColumnNode, AXPWidgetConfig } from '@acorex-platform/framework-shared/widget-core';
+import { AXRange, AXPlacement, AXStyleColorType } from '@acorex/cdk/common';
+import { AXSchedulerResource, AXSchedulerDateRange } from '@acorex/components/scheduler';
+import { AXPCommand, AXPCommandExecuteResultPromise } from '@acorex-platform/framework-shared/runtime';
+import * as _acorex_platform_module_task_management_client from '@acorex-platform/module-task-management-client';
+import * as _acorex_platform_module_dashboard_management_client from '@acorex-platform/module-dashboard-management-client';
+import * as dist_libs_modules_dashboard_management_contracts_src from 'dist/libs/modules/dashboard-management/contracts/src';
+import { AXMCommonDashboardEntityModel } from '@acorex-platform/module-dashboard-management-contracts';
+import { AXPSessionService } from '@acorex-platform/framework-client/auth';
+import { AXHolidayDate } from '@acorex/core/date-time';
+import { Subject } from 'rxjs';
+import { AXRowCommandItem, AXRowCommandItemClickEvent } from '@acorex/components/data-table';
+import { AXFormatService } from '@acorex/core/format';
+import { AXTranslationService } from '@acorex/core/translation';
+
+declare class AXPTaskBoardModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPTaskBoardModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXPTaskBoardModule, never, [typeof i1.AXPRuntimeModule], never>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXPTaskBoardModule>;
+}
+
+declare class AXMTaskFeatureModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMTaskFeatureModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXMTaskFeatureModule, never, [typeof i1$1.CommonModule, typeof i1.AXPRuntimeModule], never>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXMTaskFeatureModule>;
+}
+
+declare class AXMTaskManagementModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMTaskManagementModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXMTaskManagementModule, never, [typeof i1$1.CommonModule, typeof AXPTaskBoardModule, typeof i3.AXMCalendarManagementModule, typeof i4.AXPWidgetCoreModule, typeof AXMTaskFeatureModule], never>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXMTaskManagementModule>;
+}
+
+declare class AXMTaskManagementMenuProvider implements AXPMenuProvider {
+    private entityService;
+    private sessionService;
+    private settingsService;
+    provide(context: AXPMenuProviderContext): Promise<void>;
+    private resolveTaskBoardMenuPath;
+}
+
+declare class AXMSearchCommandProvider extends AXPSearchCommandProvider {
+    commands: AXPSearchResult[];
+}
+
+declare class AXMSettingProvider implements AXPSettingDefinitionProvider {
+    provide(context: AXPSettingDefinitionProviderContext): Promise<void>;
+}
+
+type ResetTaskBoardFiltersAssignToCurrentUserInput = Record<string, never>;
+declare const RESET_TASK_BOARD_FILTERS_ASSIGN_TO_CURRENT_USER_COMMAND_KEY: "TaskManagement.TaskBoard:ResetFiltersAssignToCurrentUser";
+/**
+ * Clears task-board filters, scopes assignee to the signed-in user, and requests a board refresh.
+ */
+declare class ResetTaskBoardFiltersAssignToCurrentUserCommand implements AXPCommand<ResetTaskBoardFiltersAssignToCurrentUserInput, void> {
+    private readonly sessionService;
+    private readonly taskBoardService;
+    private readonly vm;
+    execute(_input?: ResetTaskBoardFiltersAssignToCurrentUserInput): AXPCommandExecuteResultPromise<void>;
+    private ensureTaskTypeForGroupedViews;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ResetTaskBoardFiltersAssignToCurrentUserCommand, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ResetTaskBoardFiltersAssignToCurrentUserCommand>;
+}
+
+/** Canonical task priority — matches workflow human-task activity values (normalized to lowercase). */
+type AXPTaskPriority = 'low' | 'normal' | 'high' | 'urgent';
+/** Task board row/card accent color source. */
+type AXPTaskBoardColorBy = 'dueDate' | 'priority' | 'status';
+interface AXPTaskDueStatusPresentation {
+    name: string;
+    title: string;
+    color: string;
+    icon?: string;
+}
+/**
+ * A single label/value row rendered in a task popover metadata section.
+ */
+interface AXPTaskPopoverMetadataField {
+    name: string;
+    title: string;
+    node: AXPWidgetNode;
+}
+/**
+ * Widget definitions and context values for task popover metadata.
+ */
+interface AXPTaskPopoverMetadata {
+    context: Record<string, unknown>;
+    fields: AXPTaskPopoverMetadataField[];
+}
+/**
+ * Extended action menu item for task board with priority support.
+ * Primary actions are shown as icon-only buttons, secondary actions are shown in a dropdown.
+ */
+type AXPTaskActionMenuItem = AXPActionMenuItem & {
+    priority?: 'primary' | 'secondary';
+};
+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;
+        /** Semantic chip/badge color token (e.g. warning, success). */
+        color?: 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;
+    /**
+     * Canonical task priority (single source with workflow human-task activities).
+     */
+    priority?: AXPTaskPriority;
+    /**
+     * 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;
+}
+/** Task-board assignee/reporter picker item returned by queries and default loaders. */
+interface AXPTaskBoardUserOption {
+    id: string | number;
+    displayName: string;
+    username?: string;
+}
+/** Due-status filter keys (aligned with {@link AXPDueStatusKey} in due-status module). */
+type AXPTaskDueStatusFilterKey = 'completed' | 'no-due-date' | 'overdue' | 'due-today' | 'due-tomorrow' | 'due-this-week' | 'upcoming';
+/**
+ * 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<AXPTaskPriority | 'no_priority'>;
+    dueStatusKeys?: AXPTaskDueStatusFilterKey[];
+    /** Filter by {@link AXPEntityReference.type} entity sources (e.g. `ProjectManagement.Project`). */
+    subjectRefTypes?: string[];
+    /** Filter by {@link AXPEntityReference.id} values. */
+    subjectRefIds?: string[];
+}
+/**
+ * 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;
+}
+/** Resolved task-board provider metadata for filters, datasources, and display. */
+interface AXPTaskBoardTaskTypeOption {
+    name: string;
+    title: string;
+    icon: 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>> {
+    /** Stable provider key used for filtering, events, and task.provider. */
+    abstract get name(): string;
+    abstract getTitle(): Promise<string>;
+    abstract getIcon(): Promise<string>;
+    private readonly eventService;
+    /**
+     * 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<AXPTaskActionMenuItem[]>;
+    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): AXPCommandExecuteResultPromise;
+    /**
+     * Optional component to display in the task popover instead of the default popover content.
+     * The component must implement AXPTaskPopoverComponent interface and accept a task input.
+     * @returns A component type or a function that returns a component type (for lazy loading).
+     */
+    getComponent?(): Type<AXPTaskPopoverComponent> | (() => Promise<Type<AXPTaskPopoverComponent>>) | null;
+    /**
+     * Optional metadata for custom task popovers: widget definitions and context values rendered in view mode.
+     */
+    getPopoverMetadata?(task: AXPTask<T>): Promise<AXPTaskPopoverMetadata>;
+    refresh(): void;
+    close(): void;
+    /**
+     * Opens a task on the task board (after refresh, the board selects this task).
+     */
+    protected requestTaskBoardOpenTask(task: AXPTask<T>): void;
+}
+/**
+ * Interface that task popover components must implement.
+ * Components provided by task providers should implement this interface to receive the task data.
+ */
+declare abstract class AXPTaskPopoverComponent {
+    private readonly eventService;
+    /**
+     * The task/appointment data to display in the popover.
+     */
+    abstract task: InputSignal<AXPTask>;
+    /**
+     * Requests the task board to refresh popover/task data.
+     * Provider defaults to the current task provider.
+     */
+    protected refreshPopover(provider?: string): void;
+    /**
+     * Requests the host task board view to close the active popover.
+     * Provider defaults to the current task provider.
+     */
+    protected closePopover(provider?: string): void;
+}
+interface AXPWorkflowTaskProviderResolveOptions {
+    /** When true, clears workflow-definition caches and re-discovers providers. */
+    force?: boolean;
+}
+/**
+ * Optional resolver registered by workflow-management to discover task providers on demand.
+ */
+declare const AXP_WORKFLOW_TASK_PROVIDER_RESOLVER: InjectionToken<(options?: AXPWorkflowTaskProviderResolveOptions) => Promise<AXPWorkflowTaskProvider[]>>;
+/**
+ * Injection token for registering multiple workflow task providers.
+ */
+declare const AXP_WORKFLOW_TASK_PROVIDER: InjectionToken<AXPWorkflowTaskProvider<Record<string, any>>[] | Promise<AXPWorkflowTaskProvider<Record<string, any>>>[]>;
+
+type AXPDueStatusKey = 'completed' | 'no-due-date' | 'overdue' | 'due-today' | 'due-tomorrow' | 'due-this-week' | 'upcoming';
+interface AXPDueStatusDefinition {
+    name: AXPDueStatusKey;
+    title: string;
+    color: string;
+    icon?: string;
+    order: number;
+}
+interface AXPDueStatusEvaluationContext {
+    now: Date;
+    dueDate?: Date | null;
+    hasExplicitDueDate: boolean;
+    bookmarkConsumed: boolean;
+    weekStartsOn: number;
+}
+interface AXPDueStatusPresentation {
+    name: AXPDueStatusKey;
+    title: string;
+    color: string;
+    icon?: string;
+}
+interface AXPDueStatusResolveOptions {
+    workflowDefinitionId?: string;
+    activityType?: string;
+}
+declare abstract class AXPDueStatusProvider {
+    abstract readonly key: string;
+    abstract readonly priority: number;
+    abstract getDefinitions(): AXPDueStatusDefinition[];
+    abstract resolve(context: AXPDueStatusEvaluationContext): AXPDueStatusDefinition | null;
+}
+declare const AXP_DUE_STATUS_PROVIDERS: InjectionToken<AXPDueStatusProvider[]>;
+type AXPDueStatusFilterKey = AXPDueStatusKey;
+declare function getTaskDueStatusKey(task: AXPTask): AXPDueStatusFilterKey | undefined;
+declare function matchesTaskDueStatusFilter(task: AXPTask, dueStatusKeys: AXPDueStatusFilterKey[]): boolean;
+
+declare function resolveDueStatusFromDefinitions(definitions: AXPDueStatusDefinition[], context: AXPDueStatusEvaluationContext): AXPDueStatusDefinition | null;
+
+declare class AXMDefaultDueStatusProvider extends AXPDueStatusProvider {
+    readonly key = "default";
+    readonly priority = 0;
+    getDefinitions(): AXPDueStatusDefinition[];
+    resolve(context: AXPDueStatusEvaluationContext): AXPDueStatusDefinition | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMDefaultDueStatusProvider, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMDefaultDueStatusProvider>;
+}
+declare function getDefaultDueStatusDefinitions(): AXPDueStatusDefinition[];
+
+declare class AXPDueStatusProviderService {
+    private readonly localeService;
+    private readonly registeredProviders;
+    private readonly fallbackProvider;
+    getDefinitions(options?: AXPDueStatusResolveOptions): ReturnType<AXPDueStatusProvider['getDefinitions']>;
+    resolveForTask(task: AXPTask, options?: AXPDueStatusResolveOptions): AXPDueStatusPresentation | null;
+    attachDueStatusToTask(task: AXPTask, options?: AXPDueStatusResolveOptions): AXPTask;
+    private selectProvider;
+    private resolveWeekStartsOn;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPDueStatusProviderService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPDueStatusProviderService>;
+}
+
+declare function resolveTaskBoardAccentColor(task: AXPTask, colorBy: AXPTaskBoardColorBy): string;
+/** Maps a color token to a static BEM class backed by Tailwind @apply rules in task-board-surface.css. */
+declare function buildTaskSurfaceCssClass(colorToken: string): string;
+/** Accent stripe modifier for dashboard widget rows. */
+declare function buildTaskAccentSurfaceCssClass(colorToken: string): string;
+/** @deprecated Use {@link buildTaskSurfaceCssClass}. */
+declare function buildTaskAccentCssClass(colorToken: string): string;
+
+/** Sentinel id for the task-board assignee filter option: tasks with no assignee. */
+declare const AXM_TASK_BOARD_UNASSIGNED_ASSIGNEE_ID = "TaskManagement:TaskBoard:Assignee:Unassigned";
+/** Permission to view and filter tasks across all assignees on the task board. */
+declare const AXM_TASK_VIEW_ALL_PERMISSION: "ProjectsWork:Permission:ViewAllTasks";
+/**
+ * Returns whether the current session may filter tasks by any assignee.
+ */
+declare function canViewAllTaskAssignees(sessionService: AXPSessionService): boolean;
+declare function isTaskBoardUnassignedAssigneeId(id: string | number): boolean;
+/** Whether the user has a persisted assignee filter (including an explicit empty selection). */
+declare function hasTaskBoardSavedAssigneePreference(savedAssigneeIds: (string | number)[] | null | undefined): boolean;
+/**
+ * Resolves saved assignee ids from settings. When the setting is unset (`undefined`/`null`):
+ * - Users with view-all permission default to no assignee filter (all tasks).
+ * - Everyone else defaults to the signed-in user only.
+ * An explicit empty array means "no assignee filter" only for view-all users;
+ * for everyone else it is coerced to the signed-in user.
+ */
+declare function resolveTaskBoardSavedAssigneeIds(sessionService: AXPSessionService, savedAssigneeIds: (string | number)[] | null | undefined): (string | number)[];
+/** Assignee picker item for the signed-in user (used by task-board assignee datasource). */
+declare function resolveTaskBoardCurrentUserAssigneeItem(sessionService: AXPSessionService): {
+    id: string;
+    displayName: string;
+    username: string;
+} | null;
+/**
+ * Restricts assignee filter ids to the current user when {@link canViewAllTaskAssignees} is false.
+ * Strips the unassigned sentinel for users without view-all permission.
+ * Empty selection is only allowed for view-all users (means all assignees).
+ */
+declare function normalizeTaskBoardAssigneeIds(sessionService: AXPSessionService, assigneeIds: (string | number)[]): (string | number)[];
+/**
+ * Whether a task matches the selected assignee filter ids (OR semantics).
+ * Supports {@link AXM_TASK_BOARD_UNASSIGNED_ASSIGNEE_ID} for tasks without an assignee.
+ */
+declare function matchesTaskBoardAssigneeFilter(assigneeId: string | undefined | null, filterIds: (string | number)[]): boolean;
+/**
+ * Whether a workflow task matches assignee filters using assigned/candidate user ids.
+ */
+declare function matchesTaskBoardAssigneeUserIdsFilter(userIds: string[], filterIds: (string | number)[]): boolean;
+
+declare class AXPTaskBoardService {
+    private calendarService;
+    private calendarManagementService;
+    private readonly injector;
+    private readonly providerResolver;
+    private readonly destroyRef;
+    private readonly eventService;
+    private readonly entityEvents;
+    /** Cached resolved providers; set after first call to resolveProviders(). */
+    private resolvedProviders;
+    /** Cached resolved provider metadata; set together with {@link resolvedProviders}. */
+    private resolvedTaskTypeOptions;
+    private readonly taskResultCache;
+    private readonly taskResultInFlight;
+    private readonly taskCacheTtlMs;
+    private calendarEventTypesCache;
+    private calendarEventTypesInFlight;
+    refresh$: Subject<{
+        provider?: string;
+    }>;
+    close$: Subject<{
+        provider?: string;
+    }>;
+    openTask$: Subject<{
+        provider?: string;
+        task?: AXPTask;
+        instanceId?: string;
+        activityId?: string;
+        bookmarkId?: string;
+    }>;
+    constructor();
+    /**
+     * Requests task board refresh through broadcast events.
+     */
+    requestRefresh(provider?: string): void;
+    /**
+     * Requests active task popover close through broadcast events.
+     */
+    requestClose(provider?: string): void;
+    /**
+     * Opens a task on the task board (refresh, then select the task in the active view).
+     */
+    requestOpenTask(taskOrRef: AXPTask | {
+        instanceId: string;
+        activityId: string;
+        provider?: string;
+        bookmarkId?: string;
+    }, provider?: string): void;
+    /** Clears cached workflow task providers so the next resolve re-reads DI registrations. */
+    clearProviderCache(): void;
+    /** Clears cached task query results and calendar metadata. */
+    invalidateTaskCache(): void;
+    /**
+     * Resolves workflow task providers. Uses the optional workflow resolver when registered so discovery
+     * can be re-run after workflow definitions become available (first app load before mock seed).
+     */
+    resolveProviders(options?: AXPWorkflowTaskProviderResolveOptions): Promise<AXPWorkflowTaskProvider[]>;
+    private resolveTaskTypeOptions;
+    private getInjectedProviderEntries;
+    private flattenProviderEntries;
+    getTaskTypes(options?: AXPWorkflowTaskProviderResolveOptions): Promise<AXPWorkflowTaskProvider[]>;
+    /**
+     * Resolved provider metadata for UI filters and datasources.
+     * Call {@link resolveProviders} or {@link getTaskTypes} first.
+     */
+    getTaskTypeOptions(): AXPTaskBoardTaskTypeOption[];
+    getTaskTypeOption(name: string | undefined): AXPTaskBoardTaskTypeOption | null;
+    getTasks(options?: AXPTaskFilter): Promise<{
+        items: AXPTask[];
+        total: number;
+    }>;
+    private fetchTasksFromProviders;
+    updateTaskDateRange(task: AXPTask, range: AXSchedulerDateRange): Promise<AXPTask>;
+    updateTasks(tasks: AXPTask[]): Promise<AXPTask[]>;
+    executeCommand(command: AXPExecuteCommand, providerName: string): AXPCommandExecuteResultPromise;
+    getStatusName(key: any, providerName: string): Promise<string | null>;
+    getEvents(range: AXRange<Date>, eventTypeIds?: string[]): Promise<AXHolidayDate[]>;
+    getCalendarEventTypes(): Promise<{
+        id: string;
+        title: string;
+        color?: string;
+        icon?: string;
+    }[]>;
+    /**
+     * Returns the provider by name. Uses cached resolved providers; returns null if not resolved yet.
+     * Ensure resolveProviders() has been called (e.g. via getTaskTypes() or getTasks()) before using this.
+     */
+    getProvider(name: string | undefined): AXPWorkflowTaskProvider | null;
+    rangeCalculator(type: string): AXRange<Date> | undefined;
+    getResources(providerName: string): Promise<AXPResource[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPTaskBoardService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPTaskBoardService>;
+}
+
+declare class AXMTaskBoardDefaultTaskPopoverComponent extends AXPTaskPopoverComponent {
+    task: _angular_core.InputSignal<AXPTask<Record<string, any>>>;
+    private readonly taskBoardService;
+    private readonly calendarService;
+    protected readonly taskActions: _angular_core.WritableSignal<AXPTaskActionMenuItem[]>;
+    protected readonly primaryActions: _angular_core.Signal<AXPTaskActionMenuItem[]>;
+    protected readonly secondaryActions: _angular_core.Signal<AXPTaskActionMenuItem[]>;
+    constructor();
+    protected getActionColor(action: AXPTaskActionMenuItem): string | null;
+    protected executeAction(action: AXPTaskActionMenuItem): Promise<void>;
+    protected formatDateRange(task: AXPTask): string;
+    private formatTime;
+    private formatDate;
+    private formatDateTime;
+    private isMultiDay;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMTaskBoardDefaultTaskPopoverComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXMTaskBoardDefaultTaskPopoverComponent, "axm-task-board-default-task-popover", never, { "task": { "alias": "task"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Resolves the popover component for a task: provider custom component or the default task popover.
+ */
+declare function resolveTaskPopoverComponent(task: AXPTask, taskBoardService: AXPTaskBoardService): Promise<Type<AXPTaskPopoverComponent>>;
+
+/** Width for a single icon-only row action column. */
+declare const TASK_BOARD_GRID_ROW_ACTION_COLUMN_WIDTH = "70px";
+/** Icon-only command that opens the task details popover. */
+declare const TASK_BOARD_GRID_ROW_VIEW_ACTION: AXRowCommandItem;
+declare const TASK_BOARD_GRID_ROW_ACTION_ITEMS: AXRowCommandItem[];
+
+type AXPPriorityFilterKey = AXPTaskPriority | 'no_priority';
+declare const AXPTASK_PRIORITIES: readonly AXPTaskPriority[];
+declare const TASK_PRIORITY_ORDER: Record<AXPPriorityFilterKey, number>;
+/** Normalizes workflow or legacy task-board priority values to the canonical enum. */
+declare function normalizeTaskPriority(value: unknown): AXPTaskPriority;
+declare function getTaskPriorityColor(priority: AXPTaskPriority): string;
+/** Maps persisted or query-string priority filter keys to the canonical filter enum. */
+declare function normalizePriorityFilterKey(value: unknown): AXPPriorityFilterKey;
+declare function normalizePriorityFilterKeys(values: unknown[] | undefined): AXPPriorityFilterKey[];
+declare function getTaskPriorityFilterKey(task: AXPTask): AXPPriorityFilterKey;
+declare function matchesTaskPriorityFilter(task: AXPTask, priorities: AXPPriorityFilterKey[]): boolean;
+
+/** Maps entity status semantic colors to badge/chip tokens (`info` → `accent3`). */
+declare function mapEntityStatusColorForBadge(color: string | undefined, statusId: string | number): string;
+declare function resolveDefaultTaskStatusColor(statusId: string | number): string;
+/** Resolves the chip color for a task row, aligned with workflow popover badge layout. */
+declare function resolveTaskBoardStatusColor(task: AXPTask): string;
+/** Calendar placement for tasks without an explicit due date (received/created day, all-day). */
+declare function resolveTaskBoardCalendarPlacement(task: AXPTask): Pick<AXPTask, 'startDate' | 'endDate' | 'allDay'>;
+/**
+ * Returns tasks whose effective scheduling range overlaps the filter range (inclusive).
+ * Open tasks without an explicit due date are always included (widget-style visibility).
+ */
+declare function resolveTaskBoardSchedulingRange(task: AXPTask): {
+    from: Date;
+    end: Date;
+};
+/** Whether a task should appear for the task board's active date navigator range. */
+declare function taskOverlapsFilterRange(task: AXPTask, range?: AXRange<Date>): boolean;
+declare function filterTasksOverlappingRange<T extends AXPTask>(tasks: T[], range?: AXRange<Date>): T[];
+
+/** Resolves MLS and formats dates at display time so task labels react to locale changes. */
+declare function formatTaskI18nParamsForTranslate(raw: Record<string, unknown> | undefined, translationService: AXTranslationService, formatService: AXFormatService, settingsService: AXPSettingsService): Promise<Record<string, string>>;
+declare function getTaskTranslationKey(task: AXPTask, field: 'title' | 'description'): string | undefined;
+/** Resolves scheduler/kanban labels; popovers should use the translate pipe with {@link getTaskTranslationKey}. */
+declare function resolveTaskBoardSchedulerLabels(tasks: AXPTask[], translationService: AXTranslationService, formatService: AXFormatService, settingsService: AXPSettingsService): Promise<AXPTask[]>;
+declare function enrichTaskBoardTasks(tasks: AXPTask[], colorBy: AXPTaskBoardColorBy, dueStatusProviderService: AXPDueStatusProviderService): AXPTask[];
+
+/** Anchor for overlay positioning: native element, ElementRef, or component host via `getHostElement()`. */
+type AXMTaskPopoverAnchor = Element | ElementRef<HTMLElement>;
+interface AXMOpenTaskPopoverOverlayOptions {
+    task: AXPTask;
+    anchor: AXMTaskPopoverAnchor;
+    /** Default: `bottom-start` (below anchor, aligned to the left / start edge). */
+    placement?: AXPlacement;
+    offsetX?: number;
+    offsetY?: number;
+    adaptivityEnabled?: boolean;
+    autoFlip?: boolean;
+}
+/**
+ * Opens task-board task popovers via {@link AXOverlayService}, matching {@link AXPopoverComponent} anchor positioning.
+ */
+declare class AXMTaskBoardTaskPopoverOverlayService {
+    private readonly overlayService;
+    private readonly taskBoardService;
+    private readonly platform;
+    private readonly document;
+    private overlayRef;
+    private shellRef;
+    private activeTask;
+    private anchorElement;
+    private outsideClickHandler;
+    private keydownHandler;
+    getActiveTask(): AXPTask | null;
+    isOpen(): boolean;
+    open(options: AXMOpenTaskPopoverOverlayOptions): Promise<void>;
+    refreshTask(task: AXPTask): Promise<void>;
+    close(): void;
+    /**
+     * Normalizes an anchor to a host {@link HTMLElement} for {@link AXOverlayService}.
+     */
+    resolveAnchorElement(anchor: AXMTaskPopoverAnchor): HTMLElement | null;
+    /**
+     * Resolves an overlay anchor from a grid command-column click.
+     */
+    resolveAnchorFromCommandClick(event: AXRowCommandItemClickEvent): HTMLElement | undefined;
+    /**
+     * Resolves an overlay anchor from a native click (e.g. command button in a data table cell).
+     */
+    resolveAnchor(nativeEvent?: MouseEvent | null, htmlElement?: HTMLElement | null): HTMLElement | undefined;
+    private bindDismissHandlers;
+    /** Dropdown menus render outside the popover overlay; ignore those clicks when dismissing. */
+    private isInsideTaskPopoverInteractiveSurface;
+    private removeDismissHandlers;
+    private handleOverlayDisposed;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMTaskBoardTaskPopoverOverlayService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXMTaskBoardTaskPopoverOverlayService>;
+}
+
+declare class AXMTaskBoardTaskPopoverShellComponent {
+    task: _angular_core.InputSignal<AXPTask<Record<string, any>>>;
+    bodyComponent: _angular_core.InputSignal<Type<AXPTaskPopoverComponent>>;
+    requestClose: _angular_core.InputSignal<() => void>;
+    private readonly localeService;
+    private readonly formatService;
+    private readonly settingsService;
+    private readonly translationService;
+    protected readonly i18nParams: _angular_core.WritableSignal<Record<string, string>>;
+    protected readonly titleKey: _angular_core.Signal<string | undefined>;
+    protected readonly bodyInputs: _angular_core.Signal<{
+        task: AXPTask<Record<string, any>>;
+    }>;
+    private readonly i18nParamsEffect;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXMTaskBoardTaskPopoverShellComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXMTaskBoardTaskPopoverShellComponent, "axm-task-board-task-popover-shell", never, { "task": { "alias": "task"; "required": true; "isSignal": true; }; "bodyComponent": { "alias": "bodyComponent"; "required": true; "isSignal": true; }; "requestClose": { "alias": "requestClose"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Feeds the platform task board from persisted {@link TaskManagement.Task} rows.
+ */
+declare class AXPTaskManagementEntityTaskProvider extends AXPWorkflowTaskProvider<Record<string, unknown>> {
+    getTitle(): Promise<string>;
+    getIcon(): Promise<string>;
+    private readonly entityService;
+    private readonly calendarService;
+    private readonly dueStatusProviderService;
+    get name(): string;
+    getTasks(options?: AXPTaskFilter): Promise<{
+        items: AXPTask<Record<string, unknown>>[];
+        total: number;
+    }>;
+    updateTasks(tasksToUpdate: AXPTask<Record<string, unknown>>[]): Promise<AXPTask<Record<string, unknown>>[]>;
+    getStatuses(): Promise<AXPTaskStatus[]>;
+    getExtraFields(): Promise<AXPExtraField[]>;
+    executeCommand(command: AXPExecuteCommand): AXPCommandExecuteResultPromise;
+    getActions(task?: AXPTask<Record<string, unknown>>): Promise<AXPActionMenuItem[]>;
+    private mapRowToTask;
+    private mapPriority;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPTaskManagementEntityTaskProvider, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AXPTaskManagementEntityTaskProvider>;
+}
+
+type TaskPriority = NonNullable<AXPTask['priority']>;
+type PriorityFilterKey = TaskPriority | 'no_priority';
+type Priority = {
+    title: string;
+    name: PriorityFilterKey;
+};
+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[];
+};
+declare class AXPTaskBoardShortcutViewComponent extends AXPLayoutBaseWidgetComponent {
+    #private;
+    private readonly taskBoardService;
+    private readonly sessionService;
+    protected tasksCount: _angular_core.WritableSignal<number>;
+    protected readonly assignee: _angular_core.Signal<Assignee$1[]>;
+    protected readonly priority: _angular_core.Signal<Priority[]>;
+    protected readonly selectedTaskTypes: _angular_core.Signal<TaskType$1[]>;
+    protected readonly dateRange: _angular_core.Signal<DateRange>;
+    protected readonly title: _angular_core.Signal<string>;
+    protected readonly queryParams: _angular_core.Signal<QueryParam>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPTaskBoardShortcutViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPTaskBoardShortcutViewComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+declare const AXPTaskBoardShortcut: AXPWidgetConfig;
+
+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 {
+    #private;
+    taskClick: _angular_core.OutputEmitterRef<AXPTask<Record<string, any>>>;
+    private readonly taskBoardService;
+    private readonly taskPopoverOverlay;
+    private readonly dueStatusProviderService;
+    private readonly settingsService;
+    private readonly formatService;
+    private readonly translationService;
+    private readonly localeService;
+    private readonly destroyRef;
+    protected readonly maxItems: _angular_core.Signal<number>;
+    protected readonly assignee: _angular_core.Signal<Assignee[]>;
+    protected readonly selectedTaskTypes: _angular_core.Signal<TaskType[]>;
+    protected readonly sortBy: _angular_core.Signal<SortBy>;
+    protected readonly widgetColorBy: _angular_core.Signal<AXPTaskBoardColorBy | undefined>;
+    private readonly globalColorBy;
+    private readonly allTasks;
+    protected readonly selectedPriorities: _angular_core.WritableSignal<Set<AXPPriorityFilterKey>>;
+    protected readonly selectedDueStatuses: _angular_core.WritableSignal<Set<_acorex_platform_module_task_management_client.AXPDueStatusKey>>;
+    protected readonly effectiveColorBy: _angular_core.Signal<AXPTaskBoardColorBy>;
+    protected readonly filteredTasks: _angular_core.Signal<AXPTask<Record<string, unknown>>[]>;
+    protected readonly priorityBadges: _angular_core.Signal<{
+        name: AXPPriorityFilterKey;
+        label: string;
+        count: number;
+        color: AXStyleColorType;
+    }[]>;
+    protected readonly dueStatusBadges: _angular_core.Signal<{
+        name: _acorex_platform_module_task_management_client.AXPDueStatusKey;
+        label: string;
+        count: number;
+        color: AXStyleColorType;
+    }[]>;
+    protected readonly hasFilterToolbar: _angular_core.Signal<boolean>;
+    protected readonly hasNarrowedFilters: _angular_core.Signal<boolean>;
+    constructor();
+    protected onPriorityFilterChange(priorityKey: AXPPriorityFilterKey): void;
+    protected onDueStatusFilterChange(dueStatusKey: AXPDueStatusFilterKey): void;
+    protected isPriorityFilterActive(priorityKey: AXPPriorityFilterKey): boolean;
+    protected isDueStatusFilterActive(dueStatusKey: AXPDueStatusFilterKey): boolean;
+    protected resetFilters(): void;
+    protected onTaskClick(task: AXPTask, event: MouseEvent): Promise<void>;
+    protected getStatusColor(task: AXPTask): AXStyleColorType;
+    protected getAccentClass(task: AXPTask): string;
+    protected hasExplicitDueDate(task: AXPTask): boolean;
+    protected getProviderTitle(task: AXPTask): string | null;
+    protected getProviderIcon(task: AXPTask): string;
+    private getTypeFilteredTasks;
+    private handleBoardRefresh;
+    private reloadTasks;
+    private compareByPriority;
+    private compareByDueDate;
+    private sortTasks;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPTaskBoardWidgetViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXPTaskBoardWidgetViewComponent, "ng-component", never, {}, { "taskClick": "taskClick"; }, never, never, true, never>;
+}
+
+declare const AXPTaskBoardWidget: AXPWidgetConfig;
+
+/**
+ * Parent tab for task-management dashboard widgets in the widget gallery.
+ */
+declare const AXP_TASK_MANAGEMENT_DASHBOARD_WIDGET_CATEGORY: AXPDefinitionCategory;
+
+declare const AXP_TASK_MANAGEMENT_DASHBOARD_SUB_SHORTCUT: AXPDefinitionCategory;
+declare const AXP_TASK_MANAGEMENT_DASHBOARD_SUB_BOARD: AXPDefinitionCategory;
+
+/** Task board list tile. */
+declare const AXP_TASK_BOARD_DIMENSIONS: Required<Partial<Record<dist_libs_modules_dashboard_management_contracts_src.AXMDashboardBreakpoint, _acorex_platform_module_dashboard_management_client.AXPDashboardBreakpointDimensions>>>;
+/** Filtered task-board shortcut launcher. */
+declare const AXP_TASK_BOARD_SHORTCUT_DIMENSIONS: Required<Partial<Record<dist_libs_modules_dashboard_management_contracts_src.AXMDashboardBreakpoint, _acorex_platform_module_dashboard_management_client.AXPDashboardBreakpointDimensions>>>;
+
+type DashboardSeedWidget = AXMCommonDashboardEntityModel['widgets'][number];
+type DashboardSeedGridSize = readonly [width: number, height: number];
+declare function buildTaskBoardWidget(id: string, x: number, y: number, size?: DashboardSeedGridSize, title?: string): DashboardSeedWidget;
+declare function buildTaskBoardShortcutWidget(id: string, x: number, y: number, size?: DashboardSeedGridSize): DashboardSeedWidget;
+
+export { AXMDefaultDueStatusProvider, AXMSearchCommandProvider, AXMSettingProvider, AXMTaskBoardDefaultTaskPopoverComponent, AXMTaskBoardTaskPopoverOverlayService, AXMTaskBoardTaskPopoverShellComponent, AXMTaskManagementMenuProvider, AXMTaskManagementModule, AXM_TASK_BOARD_UNASSIGNED_ASSIGNEE_ID, AXM_TASK_VIEW_ALL_PERMISSION, AXPDueStatusProvider, AXPDueStatusProviderService, AXPTASK_PRIORITIES, AXPTaskBoardModule, AXPTaskBoardService, AXPTaskBoardShortcut, AXPTaskBoardShortcutViewComponent, AXPTaskBoardWidget, AXPTaskBoardWidgetViewComponent, AXPTaskManagementEntityTaskProvider, AXPTaskPopoverComponent, AXPWorkflowTaskProvider, AXP_DUE_STATUS_PROVIDERS, AXP_TASK_BOARD_DIMENSIONS, AXP_TASK_BOARD_SHORTCUT_DIMENSIONS, AXP_TASK_MANAGEMENT_DASHBOARD_SUB_BOARD, AXP_TASK_MANAGEMENT_DASHBOARD_SUB_SHORTCUT, AXP_TASK_MANAGEMENT_DASHBOARD_WIDGET_CATEGORY, AXP_WORKFLOW_TASK_PROVIDER, AXP_WORKFLOW_TASK_PROVIDER_RESOLVER, RESET_TASK_BOARD_FILTERS_ASSIGN_TO_CURRENT_USER_COMMAND_KEY, ResetTaskBoardFiltersAssignToCurrentUserCommand, TASK_BOARD_GRID_ROW_ACTION_COLUMN_WIDTH, TASK_BOARD_GRID_ROW_ACTION_ITEMS, TASK_BOARD_GRID_ROW_VIEW_ACTION, TASK_PRIORITY_ORDER, buildTaskAccentCssClass, buildTaskAccentSurfaceCssClass, buildTaskBoardShortcutWidget, buildTaskBoardWidget, buildTaskSurfaceCssClass, canViewAllTaskAssignees, enrichTaskBoardTasks, filterTasksOverlappingRange, formatTaskI18nParamsForTranslate, getDefaultDueStatusDefinitions, getTaskDueStatusKey, getTaskPriorityColor, getTaskPriorityFilterKey, getTaskTranslationKey, hasTaskBoardSavedAssigneePreference, isTaskBoardUnassignedAssigneeId, mapEntityStatusColorForBadge, matchesTaskBoardAssigneeFilter, matchesTaskBoardAssigneeUserIdsFilter, matchesTaskDueStatusFilter, matchesTaskPriorityFilter, normalizePriorityFilterKey, normalizePriorityFilterKeys, normalizeTaskBoardAssigneeIds, normalizeTaskPriority, resolveDefaultTaskStatusColor, resolveDueStatusFromDefinitions, resolveTaskBoardAccentColor, resolveTaskBoardCalendarPlacement, resolveTaskBoardCurrentUserAssigneeItem, resolveTaskBoardSavedAssigneeIds, resolveTaskBoardSchedulerLabels, resolveTaskBoardSchedulingRange, resolveTaskBoardStatusColor, resolveTaskPopoverComponent, taskOverlapsFilterRange };
+export type { AXMOpenTaskPopoverOverlayOptions, AXMTaskPopoverAnchor, AXPDueStatusDefinition, AXPDueStatusEvaluationContext, AXPDueStatusFilterKey, AXPDueStatusKey, AXPDueStatusPresentation, AXPDueStatusResolveOptions, AXPExtraField, AXPPriorityFilterKey, AXPResource, AXPTask, AXPTaskAction, AXPTaskActionMenuItem, AXPTaskBoardColorBy, AXPTaskBoardTaskTypeOption, AXPTaskBoardUserOption, AXPTaskDueStatusFilterKey, AXPTaskDueStatusPresentation, AXPTaskFilter, AXPTaskPopoverMetadata, AXPTaskPopoverMetadataField, AXPTaskPriority, AXPTaskStatus, AXPWorkflowTaskProviderResolveOptions, ResetTaskBoardFiltersAssignToCurrentUserInput };