@masterteam/delegations 0.0.12 → 0.1.0

package/types/masterteam-delegations.d.ts

@@ -1,167 +1,407 @@
+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>>;
 }
 
+type DelegationStatus = 'PendingApproval' | 'Scheduled' | 'Active' | 'Expired' | 'Rejected' | 'Cancelled';
+type DelegationApprovalStatus = 'NotRequired' | 'Pending' | 'Approved' | 'Rejected';
+type DelegationActivationState = 'ApprovalRequired' | 'NotStarted' | 'OutsideAllowedDay' | 'Started';
+type DelegationAllowedAction = 'View' | 'Edit' | 'Cancel' | 'Approve' | 'Reject' | 'GenerateToken' | 'StartSession' | 'Clone';
 interface DelegationUser {
     id: string;
-    userId: string;
     displayName: string;
-    mobile: string;
-    userName: string;
-    email: string;
-    photo: string;
+    email?: string;
+    photo?: string;
 }
-interface DelegationDateTime {
-    displayValue: string;
-    actualValue: string;
+interface DelegationDayRules {
+    type: 'FullRange' | 'SpecificDays';
+    specificDays: number[];
+    specificDayLabels?: string[];
 }
-interface Delegation {
-    id?: number;
-    delegateFrom?: DelegationUser;
-    delegateTo?: DelegationUser;
-    delegateFromDateTime?: DelegationDateTime;
-    delegateToDateTime?: DelegationDateTime;
-    delegationStatus?: boolean;
-    isActive?: boolean;
-    description?: string;
-    delegationDaysType?: 'FullRange' | 'SpecificDays';
-    specificDays?: number[] | null;
-}
-interface DelegationFormData {
-    delegateTo: string;
-    delegateFromDateTime: string;
-    delegateToDateTime: string;
-    delegateFrom: string;
-    description?: string;
-    delegationDaysType?: 'FullRange' | 'SpecificDays';
-    specificDays?: number[];
-    isActive?: boolean;
+interface DelegationApprovalMeta {
+    status: DelegationApprovalStatus;
+    approvedBy?: DelegationUser | null;
+    approvedAtUtc?: string | null;
+    rejectedBy?: DelegationUser | null;
+    rejectedAtUtc?: string | null;
+    rejectionReason?: string | null;
 }
-declare enum DelegationsActionKey {
-    GetDelegations = "getDelegations",
-    AddDelegation = "addDelegation",
-    UpdateDelegation = "updateDelegation",
-    DeleteDelegation = "deleteDelegation",
-    GetDelegationForm = "getDelegationForm"
+interface DelegationCancellationMeta {
+    cancelledBy?: DelegationUser | null;
+    cancelledAtUtc?: string | null;
+    cancellationReason?: string | null;
 }
-interface DelegationsStateModel extends LoadingStateShape<DelegationsActionKey> {
-    allDelegations: Delegation[];
-    selectedDelegation: Delegation | null;
+type DelegationTargetType = 'Level' | 'LevelModule' | 'ServiceModule' | 'ProcessStep' | 'Report' | 'SystemAction';
+type DelegationPermissionModuleType = 'Level' | 'LevelModule';
+type DelegationReadPolicy = 'ImplicitReadForSelectedActions' | 'ExplicitReadOnly' | 'NoReadUnlessOwnPermission';
+interface DelegationScopeOperation {
+    operationKey: string;
+    permissionCommand: string;
+    displayName: string;
+    isHighRisk?: boolean;
 }
-
-declare class GetDelegations {
-    static readonly type = "[Delegations] Get Delegations";
+interface DelegationScopeTarget {
+    targetType: DelegationTargetType;
+    targetId?: number;
+    displayName: string;
+    levelId?: number;
+    levelName?: string;
+    levelModuleId?: number;
+    domainModuleId?: number;
+    moduleKey: string;
+    moduleName?: string;
+    permissionModuleType?: DelegationPermissionModuleType;
+    permissionTargetId?: number;
+    operations: DelegationScopeOperation[];
+    dataFilter?: unknown;
+    constraints?: unknown;
 }
-declare class AddDelegation {
-    delegation: DelegationFormData;
-    static readonly type = "[Delegations] Add Delegation";
-    constructor(delegation: DelegationFormData);
+interface DelegationScopeAccessibility {
+    appAccessibilityId: number;
+    accessibilityGroupId: number;
+    moduleKey: string;
+    moduleName: string;
+    groupName: string;
 }
-declare class UpdateDelegation {
+interface DelegationScopeWarning {
+    code: string;
+    message: string;
+}
+interface DelegationScope {
+    mode: 'Explicit';
+    summary: string;
+    readPolicy: DelegationReadPolicy;
+    accessibilities: DelegationScopeAccessibility[];
+    targets: DelegationScopeTarget[];
+    warnings: DelegationScopeWarning[];
+}
+interface DelegationScopeOperationOption {
+    operationKey: string;
+    permissionCommand: string;
+    displayName: string;
+    isDelegable: boolean;
+    isHighRisk?: boolean;
+    reason?: string;
+}
+interface DelegationScopeTargetOption {
+    targetType: DelegationTargetType;
+    targetId?: number;
+    displayName: string;
+    levelId?: number;
+    levelName?: string;
+    levelModuleId?: number;
+    domainModuleId?: number;
+    moduleKey: string;
+    moduleName?: string;
+    permissionModuleType?: DelegationPermissionModuleType;
+    permissionTargetId?: number;
+    operations: DelegationScopeOperationOption[];
+}
+interface DelegationScopeAccessibilityOption {
+    appAccessibilityId: number;
+    moduleKey: string;
+    moduleName: string;
+    groups: {
+        accessibilityGroupId: number;
+        name: string;
+    }[];
+}
+interface DelegationScopeReadPolicyOption {
+    key: DelegationReadPolicy;
+    isDefault: boolean;
+}
+interface DelegationScopePreset {
+    key: string;
+    displayName: string;
+    description: string;
+}
+interface DelegationScopeOptions {
+    delegator: DelegationUser;
+    scopeModes: 'Explicit'[];
+    readPolicies: DelegationScopeReadPolicyOption[];
+    accessibilities: DelegationScopeAccessibilityOption[];
+    targets: DelegationScopeTargetOption[];
+    recommendedPresets: DelegationScopePreset[];
+}
+interface DelegationScopeRequestTargetOperation {
+    operationKey: string;
+    permissionCommand: string;
+}
+interface DelegationScopeRequestTarget {
+    targetType: DelegationTargetType;
+    targetId?: number;
+    levelId?: number;
+    levelModuleId?: number;
+    domainModuleId?: number;
+    moduleKey: string;
+    permissionModuleType?: DelegationPermissionModuleType;
+    permissionTargetId?: number;
+    operations: DelegationScopeRequestTargetOperation[];
+    dataFilter?: unknown;
+    constraints?: unknown;
+}
+interface DelegationScopeRequest {
+    mode: 'Explicit';
+    readPolicy: DelegationReadPolicy;
+    accessibilityGroupIds: number[];
+    targets: DelegationScopeRequestTarget[];
+}
+interface DelegationScopePreviewDeniedItem {
+    targetType: DelegationTargetType;
+    targetId?: number;
+    operationKey: string;
+    permissionCommand: string;
+    reasonCode: string;
+    message: string;
+}
+interface DelegationScopePreview {
+    isValid: boolean;
+    normalizedScope?: DelegationScope;
+    summary?: string | null;
+    warnings: DelegationScopeWarning[];
+    deniedItems: DelegationScopePreviewDeniedItem[];
+}
+interface Delegation {
     id: number;
-    delegation: DelegationFormData;
-    static readonly type = "[Delegations] Update Delegation";
-    constructor(id: number, delegation: DelegationFormData);
+    delegator: DelegationUser;
+    delegatedUser: DelegationUser;
+    description?: string;
+    startDateUtc: string;
+    endDateUtc: string;
+    timeZoneId: string;
+    dayRules: DelegationDayRules;
+    status: DelegationStatus;
+    statusReason: string;
+    activationState: DelegationActivationState;
+    isUsableNow: boolean;
+    requiresApproval: boolean;
+    approval: DelegationApprovalMeta;
+    cancellation: DelegationCancellationMeta;
+    createdBy: DelegationUser;
+    createdAtUtc: string;
+    updatedBy?: DelegationUser | null;
+    updatedAtUtc?: string | null;
+    allowedActions: DelegationAllowedAction[];
+    scope: DelegationScope;
+    token: {
+        canGenerate: boolean;
+        reason?: string;
+    };
+    rowVersion: string;
+    calculatedAtUtc: string;
 }
-declare class DeleteDelegation {
+interface DelegationStatusHistoryEntry {
     id: number;
-    static readonly type = "[Delegations] Delete Delegation";
-    constructor(id: number);
+    fromStatus?: DelegationStatus | null;
+    toStatus: DelegationStatus;
+    fromApprovalStatus?: DelegationApprovalStatus | null;
+    toApprovalStatus?: DelegationApprovalStatus | null;
+    actor: DelegationUser;
+    action: string;
+    reason?: string | null;
+    createdAtUtc: string;
 }
-declare class GetDelegation {
+interface DelegationDetail extends Delegation {
+    statusHistory?: DelegationStatusHistoryEntry[];
+}
+/** Minimal shape returned by login + topbar candidate listing. */
+interface DelegationSummary {
     id: number;
-    static readonly type = "[Delegations] Get Delegation";
-    constructor(id: number);
+    delegator: DelegationUser;
+    delegatedUser: DelegationUser;
+    status: DelegationStatus;
+    allowedActions: DelegationAllowedAction[];
+    startDateUtc: string;
+    endDateUtc: string;
+    scopeSummary?: string;
 }
-declare class ClearSelectedDelegation {
-    static readonly type = "[Delegations] Clear Selected Delegation";
+interface DelegationListQuery {
+    page?: number;
+    pageSize?: number;
+    status?: DelegationStatus[];
+    q?: string;
+    startFrom?: string;
+    startTo?: string;
+    endFrom?: string;
+    endTo?: string;
+    activeOn?: string;
+    approvalStatus?: DelegationApprovalStatus;
+    moduleId?: number;
+    accessibilityGroupId?: number;
+    sortBy?: 'createdAt' | 'startDate' | 'endDate' | 'status' | 'delegatorName' | 'delegatedUserName';
+    sortDir?: 'asc' | 'desc';
+}
+interface PagedResult<T> {
+    items: T[];
+    page: number;
+    pageSize: number;
+    totalCount: number;
+    totalPages: number;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    serverTimeUtc: string;
+}
+interface CreateDelegationRequest {
+    delegatedUserId: string;
+    description?: string;
+    startDateUtc: string;
+    endDateUtc: string;
+    timeZoneId: string;
+    dayRules: DelegationDayRules;
+    requiresApproval: boolean;
+    scope: DelegationScopeRequest;
+}
+interface UpdateDelegationRequest {
+    rowVersion: string;
+    description?: string;
+    startDateUtc: string;
+    endDateUtc: string;
+    timeZoneId: string;
+    dayRules: DelegationDayRules;
+    requiresApproval?: boolean;
+    scope: DelegationScopeRequest;
+}
+interface ApproveDelegationRequest {
+    rowVersion: string;
+    comment?: string;
+}
+interface RejectDelegationRequest {
+    rowVersion: string;
+    reason: string;
+}
+interface CancelDelegationRequest {
+    rowVersion: string;
+    reason: string;
+}
+interface DelegationTokenPair {
+    accessToken: string;
+    accessTokenExpiresAtUtc: string;
+    refreshToken: string;
+    refreshTokenExpiresAtUtc: string;
+    delegation: DelegationSummary;
+}
+declare enum DelegationsActionKey {
+    GetMyDelegations = "getMyDelegations",
+    GetAssignedDelegations = "getAssignedDelegations",
+    GetDelegation = "getDelegation",
+    CreateDelegation = "createDelegation",
+    UpdateDelegation = "updateDelegation",
+    ApproveDelegation = "approveDelegation",
+    RejectDelegation = "rejectDelegation",
+    CancelDelegation = "cancelDelegation",
+    GetScopeOptions = "getScopeOptions",
+    PreviewScope = "previewScope"
+}
+interface DelegationsStateModel extends LoadingStateShape<DelegationsActionKey> {
+    my: PagedResult<Delegation> | null;
+    assigned: PagedResult<Delegation> | null;
+    selected: DelegationDetail | null;
+    scopeOptions: DelegationScopeOptions | null;
+    scopePreview: DelegationScopePreview | null;
 }
 
-interface Response<T> {
-    endpoint: string;
-    status: number;
-    code: number;
-    locale: string;
-    message?: string | null;
-    errors?: any | null;
-    data: T;
-    cacheSession?: string;
+/**
+ * Topbar surface for the delegation runtime.
+ *
+ * State A — no candidates, no active session: renders nothing.
+ * State B — candidates exist, no active session: shows a "Switch identity" affordance.
+ * State C — active delegation session: shows the delegator name + back/switch.
+ *
+ * Designed to be projected into a host topbar's `[actions]` slot (alongside the
+ * existing user popover) — it does NOT replace the user dropdown.
+ */
+declare class TopbarDelegationMenu {
+    /** Path to the management page, e.g. `/control-panel/delegations` or `/delegations`. */
+    readonly managePath: _angular_core.InputSignal<string>;
+    /** Compact mode hides the inline delegator name next to the button. */
+    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<DelegationSummary[]>;
+    protected readonly hasCandidates: _angular_core.Signal<boolean>;
+    protected readonly isStarting: _angular_core.Signal<boolean>;
+    protected readonly isEnding: _angular_core.Signal<boolean>;
+    protected readonly delegatorName: _angular_core.Signal<string>;
+    /** State machine: which UI to render. */
+    protected readonly mode: _angular_core.Signal<"active" | "candidates" | "hidden">;
+    togglePopover(event: Event): void;
+    startCandidate(candidate: DelegationSummary, event: MouseEvent): void;
+    switchTo(candidate: DelegationSummary, event: MouseEvent): void;
+    endSession(event: MouseEvent): void;
+    private openConfirmation;
+    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>;
 }
 
-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>;
+interface StatusVisual {
+    i18nKey: string;
+    styleClass: string;
+}
+declare class DelegationStatusChip {
+    readonly status: _angular_core.InputSignal<DelegationStatus>;
+    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 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>;
+/**
+ * Confirmation dialog opened by the topbar menu before starting (or switching to)
+ * a delegated session. Calls the facade and closes itself on success.
+ */
+declare class StartSessionDialog {
+    readonly candidate: _angular_core.InputSignal<DelegationSummary>;
+    readonly intent: _angular_core.InputSignal<"start" | "switch">;
+    private readonly ref;
+    private readonly facade;
+    protected readonly isBusy: _angular_core.Signal<boolean>;
+    protected readonly title: _angular_core.Signal<"delegations.switch-session-confirm-title" | "delegations.start-session-confirm-title">;
+    protected readonly body: _angular_core.Signal<"delegations.switch-session-confirm-body" | "delegations.start-session-confirm-body">;
+    confirm(): void;
+    cancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StartSessionDialog, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StartSessionDialog, "mt-start-session-dialog", never, { "candidate": { "alias": "candidate"; "required": true; "isSignal": true; }; "intent": { "alias": "intent"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+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';
+/**
+ * DelegationsPage — replaces the legacy single-list CRUD view with the target
+ * two-list portal contract: "My Delegations" (I am delegator) and "Delegated To Me".
+ *
+ * - Rows render the BE-returned `allowedActions` only (never inferred).
+ * - Lifecycle actions (Approve/Reject/Cancel/Edit/StartSession) dispatch through
+ *   the facade and the row is replaced in place from the response.
+ * - Scope/detail drawer and full scope-picker form are still incremental work;
+ *   the form drawer here covers Edit/Create with the core fields.
+ */
 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>>;
     private readonly facade;
-    readonly modal: ModalService;
-    private readonly translocoService;
-    breadcrumbItems: _angular_core.WritableSignal<({
+    private readonly session;
+    private readonly modal;
+    private readonly transloco;
+    protected readonly breadcrumbItems: _angular_core.WritableSignal<({
         label: string;
         icon: string;
         routerLink: string;
@@ -174,55 +414,434 @@ 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<Delegation[]>;
+    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;
+    protected has(row: Delegation, action: DelegationAllowedAction): boolean;
+    protected formatDays(row: Delegation): 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>;
 }
 
+/**
+ * Delegation create/edit form, target-shape compliant.
+ *
+ * - Delegator is server-derived from the authenticated principal — not collected
+ *   here (admin "create on behalf of" lives behind a separate flag).
+ * - `isActive` no longer exists; status is server-calculated.
+ * - Scope is collected by `<mt-scope-picker>` (loaded from `/scope/options`)
+ *   and validated via `/scope/preview` on every change. Edit mode rehydrates
+ *   the scope from the loaded delegation.
+ */
 declare class DelegationForm implements OnInit {
-    private readonly halfWidthFieldClass;
-    private readonly fullWidthFieldClass;
+    readonly delegationForEdit: _angular_core.InputSignal<Delegation | 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>;
+    selected: _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 isDelegatingToSelf: _angular_core.Signal<boolean>;
+    protected readonly scope: _angular_core.WritableSignal<DelegationScopeRequest>;
+    protected readonly specificDaysOptions: _angular_core.WritableSignal<{
         label: string;
         value: number;
     }[]>;
-    delegationFormConfig: _angular_core.Signal<DynamicFormConfig>;
+    protected readonly delegationFormConfig: _angular_core.Signal<DynamicFormConfig>;
     constructor();
     ngOnInit(): void;
     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' | 'history';
+/**
+ * Read-only drawer that shows the full server DTO of a delegation, including
+ * its status history. Triggered from the row's "View details" action.
+ */
+declare class DelegationDetailDrawer implements OnInit {
+    /** Delegation id passed in via the modal's inputValues. */
+    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<DelegationDetail | null>;
+    protected readonly statusHistory: _angular_core.Signal<DelegationStatusHistoryEntry[]>;
+    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 AccessibilityGroupOption {
+    appAccessibilityId: number;
+    accessibilityGroupId: number;
+    moduleName: string;
+    groupName: string;
+}
+/**
+ * Scope picker driven entirely by Identity-provided options.
+ *
+ * - `[(scope)]` two-way binds a normalized `DelegationScopeRequest`.
+ * - Loads options via `DelegationsFacade.loadScopeOptions()` on init.
+ * - Calls `/scope/preview` (debounced) so the user sees the server-built summary
+ *   and denied items before they save.
+ * - Non-delegable operations render disabled with the BE-supplied `reason`.
+ */
+declare class ScopePicker implements OnInit {
+    /** Two-way bound — the form drives initial value and reads updates back. */
+    readonly scope: _angular_core.ModelSignal<DelegationScopeRequest>;
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    /** Admin scope-as-another-user — passed through to the options endpoint. */
+    readonly delegatorUserId: _angular_core.InputSignal<string | undefined>;
+    private readonly facade;
+    private readonly transloco;
+    protected readonly options: _angular_core.Signal<_masterteam_delegations.DelegationScopeOptions | 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>;
+    /** Set of accordion target keys currently expanded. */
+    private readonly expanded;
+    protected readonly readPolicies: _angular_core.Signal<_masterteam_delegations.DelegationScopeReadPolicyOption[]>;
+    /** Flat list of accessibility group options (across modules). */
+    protected readonly accessibilityGroups: _angular_core.Signal<AccessibilityGroupOption[]>;
+    /** Targets grouped by `targetType` for the accordion UI. */
+    protected readonly groupedTargets: _angular_core.Signal<{
+        type: string;
+        items: DelegationScopeTargetOption[];
+    }[]>;
+    /** O(1) lookup: is this accessibility group selected? */
+    protected readonly selectedAccessibilityIds: _angular_core.Signal<Set<number>>;
+    /** O(1) lookup: which targets are picked, and which ops per target? */
+    protected readonly selectedTargetMap: _angular_core.Signal<Map<string, Set<string>>>;
+    ngOnInit(): void;
+    constructor();
+    protected setReadPolicy(policy: DelegationReadPolicy): void;
+    protected toggleAccessibility(group: AccessibilityGroupOption): void;
+    protected isAccessibilitySelected(group: AccessibilityGroupOption): boolean;
+    protected toggleAccordion(target: DelegationScopeTargetOption): void;
+    protected isExpanded(target: DelegationScopeTargetOption): boolean;
+    protected toggleOperation(target: DelegationScopeTargetOption, op: DelegationScopeOperationOption): void;
+    protected isOperationSelected(target: DelegationScopeTargetOption, op: DelegationScopeOperationOption): boolean;
+    protected selectedOpsCount(target: DelegationScopeTargetOption): number;
+    protected reasonLabel(op: DelegationScopeOperationOption): string;
+    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 when a delegation
+ * session is active. Token-management endpoints are excluded.
+ *
+ * Register AFTER the gateway-auth interceptor (so `Authorization` is set first)
+ * and BEFORE the message interceptor (so 403s still flow through toast handling).
+ */
+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 GetDelegation {
+    id: number;
+    includeStatusHistory: boolean;
+    static readonly type = "[Delegations] Get Delegation";
+    constructor(id: number, includeStatusHistory?: boolean);
+}
+declare class ClearSelectedDelegation {
+    static readonly type = "[Delegations] Clear Selected Delegation";
+}
+declare class CreateDelegation {
+    request: CreateDelegationRequest;
+    static readonly type = "[Delegations] Create Delegation";
+    constructor(request: CreateDelegationRequest);
+}
+declare class UpdateDelegation {
+    id: number;
+    request: UpdateDelegationRequest;
+    static readonly type = "[Delegations] Update Delegation";
+    constructor(id: number, request: UpdateDelegationRequest);
+}
+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;
+    request: CancelDelegationRequest;
+    static readonly type = "[Delegations] Cancel Delegation";
+    constructor(id: number, request: CancelDelegationRequest);
+}
+declare class GetScopeOptions {
+    delegatorUserId?: string | undefined;
+    static readonly type = "[Delegations] Get Scope Options";
+    /** Admin-only override; ignored for normal users. */
+    constructor(delegatorUserId?: string | undefined);
+}
+declare class PreviewScope {
+    scope: DelegationScopeRequest;
+    static readonly type = "[Delegations] Preview Scope";
+    constructor(scope: DelegationScopeRequest);
+}
+declare class ClearScopePreview {
+    static readonly type = "[Delegations] Clear Scope Preview";
+}
+
+interface Response<T> {
+    endpoint: string;
+    status: number;
+    code: number;
+    locale: string;
+    message?: string | null;
+    errors?: any | null;
+    data: T;
+    cacheSession?: string;
+}
+
+declare class DelegationsState {
+    private http;
+    static getMyPage(state: DelegationsStateModel): PagedResult<Delegation> | null;
+    static getAssignedPage(state: DelegationsStateModel): PagedResult<Delegation> | null;
+    static getSelected(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>;
+    getMyDelegations(ctx: StateContext<DelegationsStateModel>, { query }: GetMyDelegations): rxjs.Observable<Response<PagedResult<Delegation>>>;
+    getAssignedDelegations(ctx: StateContext<DelegationsStateModel>, { query }: GetAssignedDelegations): rxjs.Observable<Response<PagedResult<Delegation>>>;
+    getDelegation(ctx: StateContext<DelegationsStateModel>, { id, includeStatusHistory }: GetDelegation): rxjs.Observable<Response<DelegationDetail>>;
+    clearSelectedDelegation(ctx: StateContext<DelegationsStateModel>): void;
+    createDelegation(ctx: StateContext<DelegationsStateModel>, { request }: CreateDelegation): rxjs.Observable<Response<Delegation>>;
+    updateDelegation(ctx: StateContext<DelegationsStateModel>, { id, request }: UpdateDelegation): rxjs.Observable<Response<Delegation>>;
+    approveDelegation(ctx: StateContext<DelegationsStateModel>, { id, request }: ApproveDelegation): rxjs.Observable<Response<Delegation>>;
+    rejectDelegation(ctx: StateContext<DelegationsStateModel>, { id, request }: RejectDelegation): rxjs.Observable<Response<Delegation>>;
+    cancelDelegation(ctx: StateContext<DelegationsStateModel>, { id, request }: CancelDelegation): rxjs.Observable<Response<Delegation>>;
+    getScopeOptions(ctx: StateContext<DelegationsStateModel>, { delegatorUserId }: GetScopeOptions): rxjs.Observable<Response<DelegationScopeOptions>>;
+    previewScope(ctx: StateContext<DelegationsStateModel>, { scope }: PreviewScope): rxjs.Observable<Response<DelegationScopePreview>>;
+    clearScopePreview(ctx: StateContext<DelegationsStateModel>): void;
+    private applyLifecycleResult;
+    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.PagedResult<_masterteam_delegations.Delegation> | null>;
+    readonly assignedPage: _angular_core.Signal<_masterteam_delegations.PagedResult<_masterteam_delegations.Delegation> | null>;
+    readonly selected: _angular_core.Signal<_masterteam_delegations.DelegationDetail | null>;
+    readonly scopeOptions: _angular_core.Signal<_masterteam_delegations.DelegationScopeOptions | null>;
+    readonly scopePreview: _angular_core.Signal<_masterteam_delegations.DelegationScopePreview | null>;
+    private readonly loadingActive;
+    private readonly errors;
+    readonly myItems: _angular_core.Signal<_masterteam_delegations.Delegation[]>;
+    readonly assignedItems: _angular_core.Signal<_masterteam_delegations.Delegation[]>;
+    readonly isLoadingMy: _angular_core.Signal<boolean>;
+    readonly isLoadingAssigned: _angular_core.Signal<boolean>;
+    readonly isLoadingDetail: _angular_core.Signal<boolean>;
+    readonly isCreating: _angular_core.Signal<boolean>;
+    readonly isUpdating: _angular_core.Signal<boolean>;
+    readonly isApproving: _angular_core.Signal<boolean>;
+    readonly isRejecting: _angular_core.Signal<boolean>;
+    readonly isCancelling: _angular_core.Signal<boolean>;
+    readonly isLoadingScopeOptions: _angular_core.Signal<boolean>;
+    readonly isPreviewingScope: _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 errorCreate: _angular_core.Signal<string | null>;
+    readonly errorUpdate: _angular_core.Signal<string | null>;
+    readonly errorApprove: _angular_core.Signal<string | null>;
+    readonly errorReject: _angular_core.Signal<string | null>;
+    readonly errorCancel: _angular_core.Signal<string | null>;
+    getMy(query?: DelegationListQuery): rxjs.Observable<void>;
+    getAssigned(query?: DelegationListQuery): rxjs.Observable<void>;
+    getOne(id: number, includeStatusHistory?: boolean): rxjs.Observable<void>;
+    clearSelected(): rxjs.Observable<void>;
+    create(request: CreateDelegationRequest): rxjs.Observable<void>;
+    update(id: number, request: UpdateDelegationRequest): rxjs.Observable<void>;
+    approve(id: number, request: ApproveDelegationRequest): rxjs.Observable<void>;
+    reject(id: number, request: RejectDelegationRequest): rxjs.Observable<void>;
+    cancel(id: number, request: CancelDelegationRequest): rxjs.Observable<void>;
+    loadScopeOptions(delegatorUserId?: string): rxjs.Observable<void>;
+    previewScope(scope: DelegationScopeRequest): rxjs.Observable<void>;
+    clearScopePreview(): rxjs.Observable<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DelegationsFacade, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DelegationsFacade>;
+}
+
+declare const DELEGATION_SESSION_STORAGE_KEY = "mt.delegation.session.v1";
+interface ActiveDelegationSession {
+    accessToken: string;
+    accessTokenExpiresAtUtc: string;
+    refreshToken: string;
+    refreshTokenExpiresAtUtc: string;
+    delegation: DelegationSummary;
+}
+declare function toActiveSession(pair: DelegationTokenPair): ActiveDelegationSession;
+declare enum DelegationSessionActionKey {
+    Bootstrap = "bootstrap",
+    StartSession = "startSession",
+    EndSession = "endSession",
+    RefreshSession = "refreshSession",
+    GetSession = "getSession"
+}
+interface DelegationSessionStateModel extends LoadingStateShape<DelegationSessionActionKey> {
+    active: ActiveDelegationSession | null;
+    candidates: DelegationSummary[];
+}
+
+/** Reads sessionStorage + login candidates, restores any tab-local active session. */
+declare class BootstrapDelegationSession {
+    static readonly type = "[DelegationSession] Bootstrap";
+}
+/** Replaces the candidate pool (called after LoginSuccess or when user.delegations changes). */
+declare class SetDelegationCandidates {
+    candidates: DelegationSummary[];
+    static readonly type = "[DelegationSession] Set Candidates";
+    constructor(candidates: DelegationSummary[]);
+}
+/** Start a delegated session for the given assignment. */
+declare class StartDelegationSession {
+    delegationId: number;
+    static readonly type = "[DelegationSession] Start";
+    constructor(delegationId: number);
+}
+/** End the current delegated session (server + local). */
+declare class EndDelegationSession {
+    options: {
+        silent?: boolean;
+    };
+    static readonly type = "[DelegationSession] End";
+    constructor(options?: {
+        silent?: boolean;
+    });
+}
+/** Atomically end current + start another. */
+declare class SwitchDelegationSession {
+    delegationId: number;
+    static readonly type = "[DelegationSession] Switch";
+    constructor(delegationId: number);
+}
+/** Refresh the delegation access token via refresh-token rotation. */
+declare class RefreshDelegationSession {
+    static readonly type = "[DelegationSession] Refresh";
+}
+/** Verify the current session against the server (used after bootstrap). */
+declare class VerifyDelegationSession {
+    static readonly type = "[DelegationSession] Verify";
+}
+/** Surface a recoverable session error from any pipeline (e.g. 403 codes). */
+declare class DelegationSessionInvalidated {
+    reason: 'TokenPrincipalMismatch' | 'NotActive' | 'ScopeDenied' | 'Expired' | 'Unknown';
+    static readonly type = "[DelegationSession] Invalidated";
+    constructor(reason: 'TokenPrincipalMismatch' | 'NotActive' | 'ScopeDenied' | 'Expired' | 'Unknown');
+}
+
+/**
+ * Filters a delegation list to "candidates the user could activate".
+ * Active + StartSession in allowedActions is the runtime gate.
+ */
+declare function pickCandidates(delegations: DelegationSummary[] | undefined | null): DelegationSummary[];
+declare class DelegationSessionState {
+    private http;
+    private actions$;
+    private store;
+    constructor();
+    static getActive(state: DelegationSessionStateModel): ActiveDelegationSession | null;
+    static getCandidates(state: DelegationSessionStateModel): DelegationSummary[];
+    static isDelegated(state: DelegationSessionStateModel): boolean;
+    static getLoadingActive(state: DelegationSessionStateModel): string[];
+    static getErrors(state: DelegationSessionStateModel): Record<string, string | null | undefined>;
+    bootstrap(ctx: StateContext<DelegationSessionStateModel>): void;
+    setCandidates(ctx: StateContext<DelegationSessionStateModel>, { candidates }: SetDelegationCandidates): void;
+    verify(ctx: StateContext<DelegationSessionStateModel>): rxjs.Observable<Response<DelegationSummary | null>>;
+    start(ctx: StateContext<DelegationSessionStateModel>, { delegationId }: StartDelegationSession): rxjs.Observable<Response<DelegationTokenPair>>;
+    end(ctx: StateContext<DelegationSessionStateModel>, { options }: EndDelegationSession): rxjs.Observable<Response<void>>;
+    switch(ctx: StateContext<DelegationSessionStateModel>, { delegationId }: SwitchDelegationSession): rxjs.Observable<void>;
+    refresh(ctx: StateContext<DelegationSessionStateModel>): rxjs.Observable<Response<DelegationTokenPair>>;
+    invalidated(ctx: StateContext<DelegationSessionStateModel>): rxjs.Observable<never>;
+    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<DelegationSummary[]>;
+    readonly isDelegated: _angular_core.Signal<boolean>;
+    private readonly loadingActive;
+    readonly delegator: _angular_core.Signal<_masterteam_delegations.DelegationUser | null>;
+    readonly accessToken: _angular_core.Signal<string | null>;
+    readonly accessTokenExpiresAtUtc: _angular_core.Signal<string | null>;
+    readonly hasCandidates: _angular_core.Signal<boolean>;
+    readonly isStartingSession: _angular_core.Signal<boolean>;
+    readonly isEndingSession: _angular_core.Signal<boolean>;
+    readonly isRefreshingSession: _angular_core.Signal<boolean>;
+    bootstrap(): rxjs.Observable<void>;
+    setCandidates(candidates: DelegationSummary[]): rxjs.Observable<void>;
+    startSession(delegationId: number): rxjs.Observable<void>;
+    endSession(opts?: {
+        silent?: boolean;
+    }): rxjs.Observable<void>;
+    switchSession(delegationId: number): rxjs.Observable<void>;
+    refreshSession(): rxjs.Observable<void>;
+    verifySession(): rxjs.Observable<void>;
+    invalidate(reason?: 'TokenPrincipalMismatch' | 'NotActive' | 'ScopeDenied' | 'Expired' | 'Unknown'): 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, BootstrapDelegationSession, CancelDelegation, ClearScopePreview, ClearSelectedDelegation, CreateDelegation, DELEGATION_SESSION_STORAGE_KEY, DelegationDetailDrawer, DelegationForm, DelegationSessionActionKey, DelegationSessionFacade, DelegationSessionInvalidated, DelegationSessionState, DelegationStatusChip, Delegations, DelegationsActionKey, DelegationsFacade, DelegationsList, DelegationsState, EndDelegationSession, GetAssignedDelegations, GetDelegation, GetMyDelegations, GetScopeOptions, PreviewScope, RefreshDelegationSession, RejectDelegation, ScopePicker, SetDelegationCandidates, StartDelegationSession, StartSessionDialog, SwitchDelegationSession, TopbarDelegationMenu, UpdateDelegation, VerifyDelegationSession, appDelegationInterceptor, pickCandidates, toActiveSession };
+export type { ActiveDelegationSession, ApproveDelegationRequest, CancelDelegationRequest, CreateDelegationRequest, Delegation, DelegationActivationState, DelegationAllowedAction, DelegationApprovalMeta, DelegationApprovalStatus, DelegationCancellationMeta, DelegationDayRules, DelegationDetail, DelegationListQuery, DelegationPermissionModuleType, DelegationReadPolicy, DelegationScope, DelegationScopeAccessibility, DelegationScopeAccessibilityOption, DelegationScopeOperation, DelegationScopeOperationOption, DelegationScopeOptions, DelegationScopePreset, DelegationScopePreview, DelegationScopePreviewDeniedItem, DelegationScopeReadPolicyOption, DelegationScopeRequest, DelegationScopeRequestTarget, DelegationScopeRequestTargetOperation, DelegationScopeTarget, DelegationScopeTargetOption, DelegationScopeWarning, DelegationSessionStateModel, DelegationStatus, DelegationStatusHistoryEntry, DelegationSummary, DelegationTargetType, DelegationTokenPair, DelegationUser, DelegationsStateModel, PagedResult, RejectDelegationRequest, UpdateDelegationRequest };