@masterteam/delegations 0.0.12 → 0.0.14

package/types/masterteam-delegations.d.ts

@@ -1,167 +1,306 @@
+import * as _masterteam_delegations from '@masterteam/delegations';
 import * as _angular_core from '@angular/core';
 import { OnInit, TemplateRef } from '@angular/core';
+import { Popover } from 'primeng/popover';
 import { TableAction, ColumnDef } from '@masterteam/components/table';
-import { ModalService } from '@masterteam/components/modal';
 import { FormControl } from '@angular/forms';
+import { HttpContext, HttpInterceptorFn } from '@angular/common/http';
+import { DynamicFormConfig } from '@masterteam/components';
 import { ModalRef } from '@masterteam/components/dialog';
-import * as _masterteam_components from '@masterteam/components';
-import { CrudStateBase, DynamicFormConfig } from '@masterteam/components';
-import { HttpContext } from '@angular/common/http';
+import { ModalService } from '@masterteam/components/modal';
 import * as rxjs from 'rxjs';
 import { StateContext } from '@ngxs/store';
-import * as _masterteam_delegations from '@masterteam/delegations';
-
-declare class Delegations {
-    private readonly router;
-    goBack(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Delegations, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Delegations, "mt-delegations", never, {}, {}, never, never, true, never>;
-}
 
 interface LoadingStateShape<L extends string = string> {
     loadingActive: L[];
     errors: Partial<Record<L, string>>;
 }
 
-interface DelegationUser {
-    id: string;
+type DelegationEffectiveStatus = 'PendingApproval' | 'Scheduled' | 'Active' | 'InactiveToday' | 'Expired' | 'Rejected' | 'Cancelled';
+type DelegationApprovalStatus = 'NotRequired' | 'Pending' | 'Approved' | 'Rejected';
+type DelegationAllowedAction = 'View' | 'Edit' | 'Approve' | 'Reject' | 'Cancel' | 'StartSession' | 'EndSession';
+type DelegationDayRuleMode = 'FullRange' | 'SpecificDays';
+interface DelegationParty {
     userId: string;
     displayName: string;
-    mobile: string;
-    userName: string;
-    email: string;
-    photo: string;
-}
-interface DelegationDateTime {
-    displayValue: string;
-    actualValue: string;
-}
-interface Delegation {
-    id?: number;
-    delegateFrom?: DelegationUser;
-    delegateTo?: DelegationUser;
-    delegateFromDateTime?: DelegationDateTime;
-    delegateToDateTime?: DelegationDateTime;
-    delegationStatus?: boolean;
-    isActive?: boolean;
+    email?: string | null;
+}
+interface DelegationApprovalInfo {
+    requiresApproval: boolean;
+    approvalStatus: DelegationApprovalStatus;
+}
+interface DelegationCancellationInfo {
+    cancelledBy?: DelegationParty | null;
+    cancelledAtUtc?: string | null;
+    cancellationReason?: string | null;
+}
+interface DelegationRow {
+    delegationId: number;
+    delegator: DelegationParty;
+    delegatedUser: DelegationParty;
+    startsAtUtc: string;
+    endsAtUtc: string;
+    timeZoneId: string;
+    dayRuleMode: DelegationDayRuleMode;
+    specificDays: number[];
+    effectiveStatus: DelegationEffectiveStatus;
+    statusReasonCode: string;
+    createdBy: DelegationParty;
+    createdAtUtc: string;
+    approval: DelegationApprovalInfo;
+    cancellation: DelegationCancellationInfo;
+    allowedActions: DelegationAllowedAction[];
+    scopeSummary: string;
+    rowVersion: string;
+}
+interface DelegationPage<T> {
+    items: T[];
+    page: number;
+    pageSize: number;
+    totalCount: number;
+}
+interface DelegationScopeTarget {
+    applicationKey: string;
+    targetType: string;
+    targetKey: string;
+    legacyModuleId?: number | null;
+    targetId?: number | null;
+    levelId?: number | null;
+    levelModuleId?: number | null;
+    domainModuleId?: number | null;
+    moduleKey?: string | null;
+    permissionModuleType?: string | null;
+    permissionTargetId?: number | null;
+    displayName?: string | null;
+}
+interface DelegationScopeAction {
+    applicationKey: string;
+    operationKey: string;
+    operationKind: string;
+    permissionCommand?: string | null;
+    businessActionCode?: string | null;
+    isHighRisk?: boolean;
+    isDelegableSnapshot?: boolean;
+}
+interface DelegationGrant {
+    applicationKey: string;
+    target: DelegationScopeTarget;
+    action: DelegationScopeAction;
+    accessibilities: unknown[];
+    dataFilters: unknown[];
+    constraints: unknown[];
+}
+interface DelegationScopeSelection {
+    grants: DelegationGrant[];
+    metadata: Record<string, unknown>;
+}
+/** `scope/options` returns the grantable set in the same grants shape. */
+type DelegationScopeOptions = DelegationScopeSelection;
+interface DelegationScopeWarning {
+    code?: string;
+    message: string;
+}
+interface DelegationScopeDeniedItem {
+    applicationKey: string;
+    targetType: string;
+    targetKey: string;
+    operationKey: string;
+    permissionCommand?: string;
+    reasonCode: string;
+}
+interface DelegationScopePreview {
+    isValid: boolean;
+    normalizedScope: DelegationScopeSelection;
+    scopeHash: string;
+    summary: string;
+    warnings: DelegationScopeWarning[];
+    deniedItems: DelegationScopeDeniedItem[];
+}
+interface DelegationStatusInfo {
+    effectiveStatus: DelegationEffectiveStatus;
+    reasonCode: string;
+    calculatedAtUtc: string;
+}
+interface DelegationDetail {
+    row: DelegationRow;
+    scope: DelegationScopeSelection;
+    status: DelegationStatusInfo;
+}
+interface DelegationDto {
+    id: number;
+    fromUserId: string;
+    toUserId: string;
     description?: string;
-    delegationDaysType?: 'FullRange' | 'SpecificDays';
-    specificDays?: number[] | null;
+    isActive?: boolean;
+    delegationDaysType: DelegationDayRuleMode;
+    specificDays: number[];
+    applicationId?: number;
+    requiresApproval?: boolean;
+    effectiveStatus: DelegationEffectiveStatus;
+    statusReasonCode: string;
+    allowedActions: DelegationAllowedAction[];
+    rowVersion: string;
+    [extra: string]: unknown;
+}
+type DelegationSortDirection = 'asc' | 'ascending' | 'desc' | 'descending';
+interface DelegationListQuery {
+    activeOnly?: boolean;
+    status?: DelegationEffectiveStatus;
+    search?: string;
+    fromUtc?: string;
+    toUtc?: string;
+    sortBy?: string;
+    sortDirection?: DelegationSortDirection;
+    page?: number;
+    pageSize?: number;
+    delegatorUserId?: string;
+    delegatedUserId?: string;
 }
-interface DelegationFormData {
+interface CreateDelegationLegacyRequest {
+    delegateFrom?: string | null;
     delegateTo: string;
+    description?: string;
     delegateFromDateTime: string;
     delegateToDateTime: string;
-    delegateFrom: string;
-    description?: string;
-    delegationDaysType?: 'FullRange' | 'SpecificDays';
+    accessibilityIds?: number[];
+    moduleIds?: number[];
+    delegationDaysType: DelegationDayRuleMode;
     specificDays?: number[];
     isActive?: boolean;
+    requiresApproval?: boolean;
 }
-declare enum DelegationsActionKey {
-    GetDelegations = "getDelegations",
-    AddDelegation = "addDelegation",
-    UpdateDelegation = "updateDelegation",
-    DeleteDelegation = "deleteDelegation",
-    GetDelegationForm = "getDelegationForm"
-}
-interface DelegationsStateModel extends LoadingStateShape<DelegationsActionKey> {
-    allDelegations: Delegation[];
-    selectedDelegation: Delegation | null;
-}
-
-declare class GetDelegations {
-    static readonly type = "[Delegations] Get Delegations";
+interface CreateDelegationV2Request {
+    delegateFrom?: string | null;
+    delegateTo: string;
+    description?: string;
+    delegateFromDateTime: string;
+    delegateToDateTime: string;
+    delegationDaysType: DelegationDayRuleMode;
+    specificDays?: number[];
+    requiresApproval: boolean;
+    scope: DelegationScopeSelection;
 }
-declare class AddDelegation {
-    delegation: DelegationFormData;
-    static readonly type = "[Delegations] Add Delegation";
-    constructor(delegation: DelegationFormData);
+type UpdateDelegationLegacyRequest = CreateDelegationLegacyRequest & {
+    rowVersion: string;
+};
+type UpdateDelegationV2Request = CreateDelegationV2Request & {
+    rowVersion: string;
+};
+interface ApproveDelegationRequest {
+    rowVersion: string;
+    reason?: string;
 }
-declare class UpdateDelegation {
-    id: number;
-    delegation: DelegationFormData;
-    static readonly type = "[Delegations] Update Delegation";
-    constructor(id: number, delegation: DelegationFormData);
+interface RejectDelegationRequest {
+    rowVersion: string;
+    reason: string;
 }
-declare class DeleteDelegation {
-    id: number;
-    static readonly type = "[Delegations] Delete Delegation";
-    constructor(id: number);
+declare enum DelegationsActionKey {
+    GetMy = "getMy",
+    GetAssigned = "getAssigned",
+    GetActive = "getActive",
+    GetDetail = "getDetail",
+    GetScopeOptions = "getScopeOptions",
+    PreviewScope = "previewScope",
+    Create = "create",
+    Update = "update",
+    Approve = "approve",
+    Reject = "reject",
+    Cancel = "cancel"
 }
-declare class GetDelegation {
-    id: number;
-    static readonly type = "[Delegations] Get Delegation";
-    constructor(id: number);
+interface DelegationsStateModel extends LoadingStateShape<DelegationsActionKey> {
+    my: DelegationPage<DelegationRow> | null;
+    assigned: DelegationPage<DelegationRow> | null;
+    active: DelegationPage<DelegationRow> | null;
+    detail: DelegationDetail | null;
+    scopeOptions: DelegationScopeOptions | null;
+    scopePreview: DelegationScopePreview | null;
 }
-declare class ClearSelectedDelegation {
-    static readonly type = "[Delegations] Clear Selected Delegation";
+
+/**
+ * Topbar surface for the delegation runtime (doc 05, 09).
+ *
+ * State A — no candidates, no active session: renders nothing.
+ * State B — candidates exist, no active session: lets the user start a session.
+ * State C — active delegated session: shows "Acting on behalf of {delegator}" +
+ *           "Executed by {actual user}", plus Back / Switch.
+ */
+declare class TopbarDelegationMenu {
+    /** Path to the management page, e.g. `/control-panel/delegations` or `/delegations`. */
+    readonly managePath: _angular_core.InputSignal<string>;
+    readonly compact: _angular_core.InputSignal<boolean>;
+    private readonly facade;
+    private readonly modal;
+    private readonly transloco;
+    protected readonly popover: _angular_core.Signal<Popover>;
+    protected readonly active: _angular_core.Signal<_masterteam_delegations.ActiveDelegationSession | null>;
+    protected readonly candidates: _angular_core.Signal<DelegationRow[]>;
+    protected readonly hasCandidates: _angular_core.Signal<boolean>;
+    protected readonly onBehalfOf: _angular_core.Signal<_masterteam_delegations.DelegationParty | null>;
+    protected readonly executedBy: _angular_core.Signal<_masterteam_delegations.DelegationParty | null>;
+    protected readonly mode: _angular_core.Signal<"active" | "candidates" | "hidden">;
+    togglePopover(event: Event): void;
+    start(row: DelegationRow, event: MouseEvent): void;
+    switchTo(row: DelegationRow, event: MouseEvent): void;
+    endSession(event: MouseEvent): void;
+    private openConfirm;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TopbarDelegationMenu, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TopbarDelegationMenu, "mt-topbar-delegation-menu", never, { "managePath": { "alias": "managePath"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-interface Response<T> {
-    endpoint: string;
-    status: number;
-    code: number;
-    locale: string;
-    message?: string | null;
-    errors?: any | null;
-    data: T;
-    cacheSession?: string;
+interface StatusVisual {
+    i18nKey: string;
+    styleClass: string;
+}
+declare class DelegationStatusChip {
+    readonly status: _angular_core.InputSignal<DelegationEffectiveStatus>;
+    protected readonly visual: _angular_core.Signal<StatusVisual>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DelegationStatusChip, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DelegationStatusChip, "mt-delegation-status-chip", never, { "status": { "alias": "status"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class DelegationsState extends CrudStateBase<Delegation, DelegationsStateModel, DelegationsActionKey> {
-    private http;
-    static getAllDelegations(state: DelegationsStateModel): Delegation[];
-    static getSelectedDelegation(state: DelegationsStateModel): Delegation | null;
-    static getLoadingActive(state: DelegationsStateModel): string[];
-    static getErrors(state: DelegationsStateModel): Record<string, string | null>;
-    getDelegations(ctx: StateContext<DelegationsStateModel>): rxjs.Observable<Response<Delegation[]>>;
-    getDelegation(ctx: StateContext<DelegationsStateModel>, { id }: GetDelegation): rxjs.Observable<Response<Delegation>>;
-    addDelegation(ctx: StateContext<DelegationsStateModel>, { delegation }: AddDelegation): rxjs.Observable<_masterteam_components.Response<Delegation>>;
-    updateDelegation(ctx: StateContext<DelegationsStateModel>, { id, delegation }: UpdateDelegation): rxjs.Observable<_masterteam_components.Response<Delegation>>;
-    deleteDelegation(ctx: StateContext<DelegationsStateModel>, { id }: DeleteDelegation): rxjs.Observable<_masterteam_components.Response<void>>;
-    clearSelectedDelegation(ctx: StateContext<DelegationsStateModel>): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DelegationsState, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DelegationsState>;
+/**
+ * Confirmation dialog before starting (or switching to) a delegated session.
+ * Calls the facade, which POSTs to `delegationToken/{id}` and stores the raw
+ * token in memory only.
+ */
+declare class StartSessionDialog {
+    readonly delegation: _angular_core.InputSignal<DelegationRow>;
+    readonly intent: _angular_core.InputSignal<"start" | "switch">;
+    private readonly ref;
+    private readonly facade;
+    protected readonly isBusy: _angular_core.Signal<boolean>;
+    protected readonly bodyKey: _angular_core.Signal<"delegations.session.switchConfirmBody" | "delegations.session.startConfirmBody">;
+    confirm(): void;
+    cancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StartSessionDialog, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StartSessionDialog, "mt-start-session-dialog", never, { "delegation": { "alias": "delegation"; "required": true; "isSignal": true; }; "intent": { "alias": "intent"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class DelegationsFacade {
-    private readonly store;
-    readonly allDelegations: _angular_core.Signal<_masterteam_delegations.Delegation[]>;
-    readonly selectedDelegation: _angular_core.Signal<_masterteam_delegations.Delegation | null>;
-    private readonly loadingActive;
-    private readonly errors;
-    readonly isLoadingDelegations: _angular_core.Signal<boolean>;
-    readonly isLoadingDelegation: _angular_core.Signal<boolean>;
-    readonly isAddingDelegation: _angular_core.Signal<boolean>;
-    readonly isUpdatingDelegation: _angular_core.Signal<boolean>;
-    readonly isDeletingDelegation: _angular_core.Signal<boolean>;
-    readonly delegationsError: _angular_core.Signal<string | null>;
-    readonly delegationError: _angular_core.Signal<string | null>;
-    readonly addDelegationError: _angular_core.Signal<string | null>;
-    readonly updateDelegationError: _angular_core.Signal<string | null>;
-    readonly deleteDelegationError: _angular_core.Signal<string | null>;
-    readonly activeDelegations: _angular_core.Signal<_masterteam_delegations.Delegation[]>;
-    readonly inactiveDelegations: _angular_core.Signal<_masterteam_delegations.Delegation[]>;
-    getDelegations(): rxjs.Observable<void>;
-    addDelegation(delegation: DelegationFormData): rxjs.Observable<void>;
-    updateDelegation(id: number, delegation: DelegationFormData): rxjs.Observable<void>;
-    deleteDelegation(id: number): rxjs.Observable<void>;
-    loadDelegation(id: number): rxjs.Observable<void>;
-    clearSelectedDelegation(): rxjs.Observable<void>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DelegationsFacade, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DelegationsFacade>;
+declare class Delegations {
+    private readonly router;
+    goBack(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Delegations, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Delegations, "mt-delegations", never, {}, {}, never, never, true, never>;
 }
 
+type DelegationTab = 'my' | 'assigned';
+/**
+ * Delegations portal page (doc 02, 09): two lists — My Delegations (current user
+ * is delegator) and Delegated To Me (current user is delegate). Rows render only
+ * the BE-returned `allowedActions`; status comes from `effectiveStatus`.
+ */
 declare class DelegationsList implements OnInit {
-    statusCol: _angular_core.Signal<TemplateRef<any>>;
-    userCol: _angular_core.Signal<TemplateRef<any>>;
-    userCol2: _angular_core.Signal<TemplateRef<any>>;
-    daysCol: _angular_core.Signal<TemplateRef<any>>;
+    /**
+     * Admin/control-panel breadcrumb. Hidden on the client self-service surface
+     * (its links point at /control-panel/*). Bound from route data via
+     * `withComponentInputBinding()` — admin leaves it default; client passes
+     * `data: { showBreadcrumb: false }`.
+     */
+    readonly showBreadcrumb: _angular_core.InputSignal<boolean>;
     private readonly facade;
-    readonly modal: ModalService;
-    private readonly translocoService;
-    breadcrumbItems: _angular_core.WritableSignal<({
+    private readonly modal;
+    private readonly transloco;
+    protected readonly breadcrumbItems: _angular_core.WritableSignal<({
         label: string;
         icon: string;
         routerLink: string;
@@ -174,55 +313,401 @@ declare class DelegationsList implements OnInit {
         icon?: undefined;
         routerLink?: undefined;
     })[]>;
-    delegations: _angular_core.Signal<Delegation[]>;
-    tabs: _angular_core.WritableSignal<{
+    protected readonly activeTab: _angular_core.WritableSignal<DelegationTab>;
+    protected readonly tabs: _angular_core.WritableSignal<{
+        value: DelegationTab;
         label: string;
-        value: string;
     }[]>;
-    activeTab: _angular_core.WritableSignal<string>;
-    tableActions: _angular_core.WritableSignal<TableAction[]>;
-    deletingRowIds: _angular_core.WritableSignal<any[]>;
-    rowActions: _angular_core.WritableSignal<TableAction[]>;
-    tableColumns: _angular_core.WritableSignal<ColumnDef[]>;
-    loading: _angular_core.Signal<boolean>;
-    private allDelegations;
-    private activeDelegations;
-    private inactiveDelegations;
+    protected readonly isLoading: _angular_core.Signal<boolean>;
+    protected readonly rows: _angular_core.Signal<DelegationRow[]>;
+    statusCol: _angular_core.Signal<TemplateRef<unknown>>;
+    userCol: _angular_core.Signal<TemplateRef<unknown>>;
+    scopeCol: _angular_core.Signal<TemplateRef<unknown>>;
+    daysCol: _angular_core.Signal<TemplateRef<unknown>>;
+    protected readonly tableActions: _angular_core.WritableSignal<TableAction[]>;
+    protected readonly rowActions: _angular_core.WritableSignal<TableAction[]>;
+    protected readonly tableColumns: _angular_core.WritableSignal<ColumnDef[]>;
+    private readonly busyIds;
     private readonly weekdayKeys;
     ngOnInit(): void;
-    formatDelegationDays(row: Delegation): string;
-    addDelegationDialog(delegation?: any | null): void;
+    protected switchTab(tab: DelegationTab): void;
+    private loadCurrentTab;
+    private reloadCurrentTab;
+    protected has(row: DelegationRow, action: DelegationAllowedAction): boolean;
+    protected formatDays(row: DelegationRow): string;
+    private viewDetails;
+    private openForm;
+    private approve;
+    private reject;
+    private cancel;
+    private startSession;
+    private mark;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<DelegationsList, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DelegationsList, "mt-delegations-list", never, {}, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DelegationsList, "mt-delegations-list", never, { "showBreadcrumb": { "alias": "showBreadcrumb"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
+/**
+ * Delegation create/edit form (doc 04). Uses the v2 explicit-scope endpoints so
+ * the persisted `DelegationScopeSelection` matches what scope/preview validated.
+ *
+ * - Delegator is server-derived; only the delegated user is collected.
+ * - On edit, scope grants + rowVersion come from the loaded detail.
+ * - Times are sent in UTC ISO; wrappers set timeZoneId = UTC.
+ */
 declare class DelegationForm implements OnInit {
-    private readonly halfWidthFieldClass;
-    private readonly fullWidthFieldClass;
+    readonly delegationForEdit: _angular_core.InputSignal<DelegationRow | null>;
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    private readonly halfWidth;
+    private readonly fullWidth;
     modal: ModalService;
     ref: ModalRef;
-    delegationForEdit: _angular_core.InputSignal<Delegation | null>;
-    private readonly translocoService;
+    private readonly transloco;
     private readonly facade;
-    selectedDelegation: _angular_core.Signal<Delegation | null>;
     delegationFormControl: FormControl<any>;
     formValue: _angular_core.Signal<any>;
-    getDelegationFormLoading: _angular_core.Signal<boolean>;
-    isAddingDelegation: _angular_core.Signal<boolean>;
-    isUpdatingDelegation: _angular_core.Signal<boolean>;
+    detail: _angular_core.Signal<_masterteam_delegations.DelegationDetail | null>;
+    isDetailLoading: _angular_core.Signal<boolean>;
+    isSaving: _angular_core.Signal<boolean>;
     context: HttpContext;
-    isDelegatingToSelf: _angular_core.Signal<boolean>;
-    specificDaysOptions: _angular_core.WritableSignal<{
+    protected readonly scope: _angular_core.WritableSignal<DelegationScopeSelection>;
+    protected readonly specificDaysOptions: _angular_core.WritableSignal<{
         label: string;
         value: number;
     }[]>;
-    delegationFormConfig: _angular_core.Signal<DynamicFormConfig>;
+    protected readonly formConfig: _angular_core.Signal<DynamicFormConfig>;
     constructor();
     ngOnInit(): void;
+    protected readonly canSubmit: _angular_core.Signal<boolean>;
     onSubmit(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<DelegationForm, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DelegationForm, "mt-delegation-form", never, { "delegationForEdit": { "alias": "delegationForEdit"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DelegationForm, "mt-delegation-form", never, { "delegationForEdit": { "alias": "delegationForEdit"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type DetailTab = 'overview' | 'scope';
+/**
+ * Read-only drawer that shows the full `DelegationDetail` ({ row, scope, status }).
+ */
+declare class DelegationDetailDrawer implements OnInit {
+    readonly delegationId: _angular_core.InputSignal<number>;
+    private readonly facade;
+    private readonly transloco;
+    protected readonly ref: ModalRef;
+    protected readonly tabs: {
+        key: DetailTab;
+        i18n: string;
+    }[];
+    protected readonly activeTab: _angular_core.WritableSignal<DetailTab>;
+    protected readonly isLoading: _angular_core.Signal<boolean>;
+    protected readonly detail: _angular_core.Signal<_masterteam_delegations.DelegationDetail | null>;
+    protected readonly row: _angular_core.Signal<_masterteam_delegations.DelegationRow | null>;
+    ngOnInit(): void;
+    protected setTab(tab: DetailTab): void;
+    protected approvalLabel(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DelegationDetailDrawer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DelegationDetailDrawer, "mt-delegation-detail-drawer", never, { "delegationId": { "alias": "delegationId"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface TargetGroup {
+    key: string;
+    target: DelegationScopeTarget;
+    grants: DelegationGrant[];
+}
+/**
+ * Grants-based scope picker (doc 03). Driven entirely by `scope/options`:
+ * - lists grantable target/action pairs returned by the backend,
+ * - lets the user toggle each grant,
+ * - calls `scope/preview` (debounced) and surfaces summary / warnings / denied.
+ *
+ * `[(scope)]` two-way binds a `DelegationScopeSelection`. The component never
+ * invents permission metadata — it only echoes grants returned by options.
+ */
+declare class ScopePicker implements OnInit {
+    readonly scope: _angular_core.ModelSignal<DelegationScopeSelection>;
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    readonly delegatorUserId: _angular_core.InputSignal<string | undefined>;
+    private readonly facade;
+    protected readonly options: _angular_core.Signal<DelegationScopeSelection | null>;
+    protected readonly preview: _angular_core.Signal<_masterteam_delegations.DelegationScopePreview | null>;
+    protected readonly isLoadingOptions: _angular_core.Signal<boolean>;
+    protected readonly isPreviewing: _angular_core.Signal<boolean>;
+    /** Grantable options grouped by target. */
+    protected readonly groups: _angular_core.Signal<TargetGroup[]>;
+    /** Selected grant keys for O(1) checkbox state. */
+    protected readonly selectedKeys: _angular_core.Signal<Set<string>>;
+    private readonly expanded;
+    ngOnInit(): void;
+    constructor();
+    protected isExpanded(group: TargetGroup): boolean;
+    protected toggleAccordion(group: TargetGroup): void;
+    protected isSelected(grant: DelegationGrant): boolean;
+    protected toggleGrant(grant: DelegationGrant): void;
+    protected selectedCount(group: TargetGroup): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScopePicker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScopePicker, "mt-scope-picker", never, { "scope": { "alias": "scope"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "delegatorUserId": { "alias": "delegatorUserId"; "required": false; "isSignal": true; }; }, { "scope": "scopeChange"; }, never, never, true, never>;
+}
+
+/**
+ * Adds `app-delegation: Bearer <token>` to outgoing requests while a delegated
+ * session is active. Register AFTER the gateway-auth interceptor (so the normal
+ * `Authorization` header is set first) and BEFORE the message interceptor.
+ */
+declare const appDelegationInterceptor: HttpInterceptorFn;
+
+declare class GetMyDelegations {
+    query: DelegationListQuery;
+    static readonly type = "[Delegations] Get My Delegations";
+    constructor(query?: DelegationListQuery);
+}
+declare class GetAssignedDelegations {
+    query: DelegationListQuery;
+    static readonly type = "[Delegations] Get Assigned Delegations";
+    constructor(query?: DelegationListQuery);
+}
+declare class GetActiveAssignedDelegations {
+    query: DelegationListQuery;
+    static readonly type = "[Delegations] Get Active Assigned Delegations";
+    constructor(query?: DelegationListQuery);
+}
+declare class GetDelegationDetail {
+    id: number;
+    static readonly type = "[Delegations] Get Delegation Detail";
+    constructor(id: number);
+}
+declare class ClearDelegationDetail {
+    static readonly type = "[Delegations] Clear Delegation Detail";
+}
+declare class GetScopeOptions {
+    delegatorUserId?: string | undefined;
+    static readonly type = "[Delegations] Get Scope Options";
+    constructor(delegatorUserId?: string | undefined);
+}
+declare class PreviewScope {
+    scope: DelegationScopeSelection;
+    static readonly type = "[Delegations] Preview Scope";
+    constructor(scope: DelegationScopeSelection);
+}
+declare class ClearScopePreview {
+    static readonly type = "[Delegations] Clear Scope Preview";
+}
+declare class CreateDelegationLegacy {
+    request: CreateDelegationLegacyRequest;
+    static readonly type = "[Delegations] Create Delegation (legacy)";
+    constructor(request: CreateDelegationLegacyRequest);
+}
+declare class CreateDelegationV2 {
+    request: CreateDelegationV2Request;
+    static readonly type = "[Delegations] Create Delegation (v2)";
+    constructor(request: CreateDelegationV2Request);
+}
+declare class UpdateDelegationLegacy {
+    id: number;
+    request: UpdateDelegationLegacyRequest;
+    static readonly type = "[Delegations] Update Delegation (legacy)";
+    constructor(id: number, request: UpdateDelegationLegacyRequest);
+}
+declare class UpdateDelegationV2 {
+    id: number;
+    request: UpdateDelegationV2Request;
+    static readonly type = "[Delegations] Update Delegation (v2)";
+    constructor(id: number, request: UpdateDelegationV2Request);
+}
+declare class ApproveDelegation {
+    id: number;
+    request: ApproveDelegationRequest;
+    static readonly type = "[Delegations] Approve Delegation";
+    constructor(id: number, request: ApproveDelegationRequest);
+}
+declare class RejectDelegation {
+    id: number;
+    request: RejectDelegationRequest;
+    static readonly type = "[Delegations] Reject Delegation";
+    constructor(id: number, request: RejectDelegationRequest);
+}
+declare class CancelDelegation {
+    id: number;
+    rowVersion: string;
+    asAdmin: boolean;
+    static readonly type = "[Delegations] Cancel Delegation";
+    constructor(id: number, rowVersion: string, asAdmin?: boolean);
+}
+
+interface ApiErrorBody {
+    code: string;
+    message: string;
+    details?: Record<string, unknown> | null;
+}
+interface Response<T> {
+    endpoint: string;
+    status: number;
+    code: number;
+    locale: string;
+    message?: string | null;
+    errors?: ApiErrorBody | null;
+    data: T;
+    cacheSession?: string | null;
+    correlationId?: string | null;
+}
+
+declare class DelegationsState {
+    private http;
+    static getMy(state: DelegationsStateModel): DelegationPage<DelegationRow> | null;
+    static getAssigned(state: DelegationsStateModel): DelegationPage<DelegationRow> | null;
+    static getActive(state: DelegationsStateModel): DelegationPage<DelegationRow> | null;
+    static getDetail(state: DelegationsStateModel): DelegationDetail | null;
+    static getScopeOptions(state: DelegationsStateModel): DelegationScopeOptions | null;
+    static getScopePreview(state: DelegationsStateModel): DelegationScopePreview | null;
+    static getLoadingActive(state: DelegationsStateModel): string[];
+    static getErrors(state: DelegationsStateModel): Record<string, string | null | undefined>;
+    getMy(ctx: StateContext<DelegationsStateModel>, { query }: GetMyDelegations): rxjs.Observable<Response<DelegationPage<DelegationRow>>>;
+    getAssigned(ctx: StateContext<DelegationsStateModel>, { query }: GetAssignedDelegations): rxjs.Observable<Response<DelegationPage<DelegationRow>>>;
+    getActive(ctx: StateContext<DelegationsStateModel>, { query }: GetActiveAssignedDelegations): rxjs.Observable<Response<DelegationPage<DelegationRow>>>;
+    getDetail(ctx: StateContext<DelegationsStateModel>, { id }: GetDelegationDetail): rxjs.Observable<Response<DelegationDetail>>;
+    clearDetail(ctx: StateContext<DelegationsStateModel>): void;
+    getScopeOptions(ctx: StateContext<DelegationsStateModel>, { delegatorUserId }: GetScopeOptions): rxjs.Observable<Response<_masterteam_delegations.DelegationScopeSelection>>;
+    previewScope(ctx: StateContext<DelegationsStateModel>, { scope }: PreviewScope): rxjs.Observable<Response<DelegationScopePreview>>;
+    clearScopePreview(ctx: StateContext<DelegationsStateModel>): void;
+    createLegacy(ctx: StateContext<DelegationsStateModel>, { request }: CreateDelegationLegacy): rxjs.Observable<Response<DelegationDto>>;
+    createV2(ctx: StateContext<DelegationsStateModel>, { request }: CreateDelegationV2): rxjs.Observable<Response<DelegationDto>>;
+    updateLegacy(ctx: StateContext<DelegationsStateModel>, { id, request }: UpdateDelegationLegacy): rxjs.Observable<Response<DelegationDto>>;
+    updateV2(ctx: StateContext<DelegationsStateModel>, { id, request }: UpdateDelegationV2): rxjs.Observable<Response<DelegationDto>>;
+    approve(ctx: StateContext<DelegationsStateModel>, { id, request }: ApproveDelegation): rxjs.Observable<Response<DelegationDto>>;
+    reject(ctx: StateContext<DelegationsStateModel>, { id, request }: RejectDelegation): rxjs.Observable<Response<DelegationDto>>;
+    cancel(ctx: StateContext<DelegationsStateModel>, { id, rowVersion, asAdmin }: CancelDelegation): rxjs.Observable<Response<boolean>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DelegationsState, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DelegationsState>;
+}
+
+declare class DelegationsFacade {
+    private readonly store;
+    readonly myPage: _angular_core.Signal<_masterteam_delegations.DelegationPage<_masterteam_delegations.DelegationRow> | null>;
+    readonly assignedPage: _angular_core.Signal<_masterteam_delegations.DelegationPage<_masterteam_delegations.DelegationRow> | null>;
+    readonly activePage: _angular_core.Signal<_masterteam_delegations.DelegationPage<_masterteam_delegations.DelegationRow> | null>;
+    readonly detail: _angular_core.Signal<_masterteam_delegations.DelegationDetail | null>;
+    readonly scopeOptions: _angular_core.Signal<DelegationScopeSelection | null>;
+    readonly scopePreview: _angular_core.Signal<_masterteam_delegations.DelegationScopePreview | null>;
+    private readonly loadingActive;
+    private readonly errors;
+    readonly myItems: _angular_core.Signal<_masterteam_delegations.DelegationRow[]>;
+    readonly assignedItems: _angular_core.Signal<_masterteam_delegations.DelegationRow[]>;
+    readonly activeItems: _angular_core.Signal<_masterteam_delegations.DelegationRow[]>;
+    readonly isLoadingMy: _angular_core.Signal<boolean>;
+    readonly isLoadingAssigned: _angular_core.Signal<boolean>;
+    readonly isLoadingActive: _angular_core.Signal<boolean>;
+    readonly isLoadingDetail: _angular_core.Signal<boolean>;
+    readonly isLoadingScopeOptions: _angular_core.Signal<boolean>;
+    readonly isPreviewingScope: _angular_core.Signal<boolean>;
+    readonly isSaving: _angular_core.Signal<boolean>;
+    readonly isApproving: _angular_core.Signal<boolean>;
+    readonly isRejecting: _angular_core.Signal<boolean>;
+    readonly isCancelling: _angular_core.Signal<boolean>;
+    readonly errorMy: _angular_core.Signal<string | null>;
+    readonly errorAssigned: _angular_core.Signal<string | null>;
+    readonly errorDetail: _angular_core.Signal<string | null>;
+    readonly errorSave: _angular_core.Signal<string | null>;
+    getMy(query?: DelegationListQuery): rxjs.Observable<void>;
+    getAssigned(query?: DelegationListQuery): rxjs.Observable<void>;
+    getActive(query?: DelegationListQuery): rxjs.Observable<void>;
+    getDetail(id: number): rxjs.Observable<void>;
+    clearDetail(): rxjs.Observable<void>;
+    loadScopeOptions(delegatorUserId?: string): rxjs.Observable<void>;
+    previewScope(scope: DelegationScopeSelection): rxjs.Observable<void>;
+    clearScopePreview(): rxjs.Observable<void>;
+    createLegacy(request: CreateDelegationLegacyRequest): rxjs.Observable<void>;
+    createV2(request: CreateDelegationV2Request): rxjs.Observable<void>;
+    updateLegacy(id: number, request: UpdateDelegationLegacyRequest): rxjs.Observable<void>;
+    updateV2(id: number, request: UpdateDelegationV2Request): rxjs.Observable<void>;
+    approve(id: number, request: ApproveDelegationRequest): rxjs.Observable<void>;
+    reject(id: number, request: RejectDelegationRequest): rxjs.Observable<void>;
+    cancel(id: number, rowVersion: string, asAdmin?: boolean): rxjs.Observable<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DelegationsFacade, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DelegationsFacade>;
+}
+
+/**
+ * Active delegated session. Memory-only by design (doc 05):
+ * the delegation token is never persisted to long-lived storage.
+ *
+ * `delegation.delegatedUser` is the executed-by (actual logged-in) user and
+ * `delegation.delegator` is the on-behalf-of user — both already present on the
+ * row from the active-delegations endpoint.
+ */
+interface ActiveDelegationSession {
+    token: string;
+    delegation: DelegationRow;
+}
+type DelegationSessionInvalidationReason = 'TokenInvalid' | 'SessionMismatch' | 'ScopeChanged' | 'Forbidden' | 'Logout' | 'UserSwitch' | 'Manual';
+declare enum DelegationSessionActionKey {
+    LoadCandidates = "loadCandidates",
+    StartSession = "startSession"
+}
+interface DelegationSessionStateModel extends LoadingStateShape<DelegationSessionActionKey> {
+    active: ActiveDelegationSession | null;
+    candidates: DelegationRow[];
+}
+
+/** Fetch the active delegations the current user may start (user/activedelegations). */
+declare class LoadDelegationCandidates {
+    static readonly type = "[DelegationSession] Load Candidates";
+}
+/** Start a delegated session for the given assignment row. */
+declare class StartDelegationSession {
+    delegation: DelegationRow;
+    static readonly type = "[DelegationSession] Start";
+    constructor(delegation: DelegationRow);
+}
+/** End the current delegated session. Client-local only (doc 05). */
+declare class EndDelegationSession {
+    reason: DelegationSessionInvalidationReason;
+    static readonly type = "[DelegationSession] End";
+    constructor(reason?: DelegationSessionInvalidationReason);
+}
+/** Switch directly from the current session to another delegation. */
+declare class SwitchDelegationSession {
+    delegation: DelegationRow;
+    static readonly type = "[DelegationSession] Switch";
+    constructor(delegation: DelegationRow);
+}
+
+declare class DelegationSessionState {
+    private http;
+    private actions$;
+    private store;
+    constructor();
+    static getActive(state: DelegationSessionStateModel): ActiveDelegationSession | null;
+    static getCandidates(state: DelegationSessionStateModel): DelegationRow[];
+    static isDelegated(state: DelegationSessionStateModel): boolean;
+    static getLoadingActive(state: DelegationSessionStateModel): string[];
+    static getErrors(state: DelegationSessionStateModel): Record<string, string | null | undefined>;
+    loadCandidates(ctx: StateContext<DelegationSessionStateModel>): rxjs.Observable<Response<DelegationPage<DelegationRow>>>;
+    start(ctx: StateContext<DelegationSessionStateModel>, { delegation }: StartDelegationSession): rxjs.Observable<Response<string>>;
+    end(ctx: StateContext<DelegationSessionStateModel>): rxjs.Observable<never>;
+    switch(ctx: StateContext<DelegationSessionStateModel>, { delegation }: SwitchDelegationSession): rxjs.Observable<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DelegationSessionState, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DelegationSessionState>;
+}
+
+declare class DelegationSessionFacade {
+    private readonly store;
+    readonly active: _angular_core.Signal<_masterteam_delegations.ActiveDelegationSession | null>;
+    readonly candidates: _angular_core.Signal<DelegationRow[]>;
+    readonly isDelegated: _angular_core.Signal<boolean>;
+    private readonly loadingActive;
+    /** Raw delegation token for the `app-delegation` header. */
+    readonly token: _angular_core.Signal<string | null>;
+    /** On-behalf-of (delegator). */
+    readonly onBehalfOf: _angular_core.Signal<_masterteam_delegations.DelegationParty | null>;
+    /** Executed-by (actual logged-in / delegated user). */
+    readonly executedBy: _angular_core.Signal<_masterteam_delegations.DelegationParty | null>;
+    readonly hasCandidates: _angular_core.Signal<boolean>;
+    readonly isStarting: _angular_core.Signal<boolean>;
+    readonly isLoadingCandidates: _angular_core.Signal<boolean>;
+    loadCandidates(): rxjs.Observable<void>;
+    startSession(delegation: DelegationRow): rxjs.Observable<void>;
+    switchSession(delegation: DelegationRow): rxjs.Observable<void>;
+    endSession(reason?: DelegationSessionInvalidationReason): rxjs.Observable<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DelegationSessionFacade, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DelegationSessionFacade>;
 }
 
-export { AddDelegation, ClearSelectedDelegation, DelegationForm, Delegations, DelegationsActionKey, DelegationsFacade, DelegationsList, DelegationsState, DeleteDelegation, GetDelegation, GetDelegations, UpdateDelegation };
-export type { Delegation, DelegationDateTime, DelegationFormData, DelegationUser, DelegationsStateModel };
+export { ApproveDelegation, CancelDelegation, ClearDelegationDetail, ClearScopePreview, CreateDelegationLegacy, CreateDelegationV2, DelegationDetailDrawer, DelegationForm, DelegationSessionActionKey, DelegationSessionFacade, DelegationSessionState, DelegationStatusChip, Delegations, DelegationsActionKey, DelegationsFacade, DelegationsList, DelegationsState, EndDelegationSession, GetActiveAssignedDelegations, GetAssignedDelegations, GetDelegationDetail, GetMyDelegations, GetScopeOptions, LoadDelegationCandidates, PreviewScope, RejectDelegation, ScopePicker, StartDelegationSession, StartSessionDialog, SwitchDelegationSession, TopbarDelegationMenu, UpdateDelegationLegacy, UpdateDelegationV2, appDelegationInterceptor };
+export type { ActiveDelegationSession, ApproveDelegationRequest, CreateDelegationLegacyRequest, CreateDelegationV2Request, DelegationAllowedAction, DelegationApprovalInfo, DelegationApprovalStatus, DelegationCancellationInfo, DelegationDayRuleMode, DelegationDetail, DelegationDto, DelegationEffectiveStatus, DelegationGrant, DelegationListQuery, DelegationPage, DelegationParty, DelegationRow, DelegationScopeAction, DelegationScopeDeniedItem, DelegationScopeOptions, DelegationScopePreview, DelegationScopeSelection, DelegationScopeTarget, DelegationScopeWarning, DelegationSessionInvalidationReason, DelegationSessionStateModel, DelegationSortDirection, DelegationStatusInfo, DelegationsStateModel, RejectDelegationRequest, UpdateDelegationLegacyRequest, UpdateDelegationV2Request };