@masterteam/delegations 0.1.0 → 0.2.0

package/types/masterteam-delegations.d.ts

@@ -16,335 +16,233 @@ interface LoadingStateShape<L extends string = string> {
     errors: Partial<Record<L, string>>;
 }
 
-type DelegationStatus = 'PendingApproval' | 'Scheduled' | 'Active' | 'Expired' | 'Rejected' | 'Cancelled';
+type DelegationEffectiveStatus = 'PendingApproval' | 'Scheduled' | 'Active' | 'InactiveToday' | '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;
+type DelegationAllowedAction = 'View' | 'Edit' | 'Approve' | 'Reject' | 'Cancel' | 'StartSession' | 'EndSession';
+type DelegationDayRuleMode = 'FullRange' | 'SpecificDays';
+interface DelegationParty {
+    userId: string;
     displayName: string;
-    email?: string;
-    photo?: string;
+    email?: string | null;
 }
-interface DelegationDayRules {
-    type: 'FullRange' | 'SpecificDays';
-    specificDays: number[];
-    specificDayLabels?: string[];
-}
-interface DelegationApprovalMeta {
-    status: DelegationApprovalStatus;
-    approvedBy?: DelegationUser | null;
-    approvedAtUtc?: string | null;
-    rejectedBy?: DelegationUser | null;
-    rejectedAtUtc?: string | null;
-    rejectionReason?: string | null;
-}
-interface DelegationCancellationMeta {
-    cancelledBy?: DelegationUser | null;
+interface DelegationApprovalInfo {
+    requiresApproval: boolean;
+    approvalStatus: DelegationApprovalStatus;
+}
+interface DelegationCancellationInfo {
+    cancelledBy?: DelegationParty | null;
     cancelledAtUtc?: string | null;
     cancellationReason?: string | 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;
-}
-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;
-}
-interface DelegationScopeAccessibility {
-    appAccessibilityId: number;
-    accessibilityGroupId: number;
-    moduleKey: string;
-    moduleName: string;
-    groupName: string;
-}
-interface DelegationScopeWarning {
-    code: string;
-    message: string;
+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 DelegationScope {
-    mode: 'Explicit';
-    summary: string;
-    readPolicy: DelegationReadPolicy;
-    accessibilities: DelegationScopeAccessibility[];
-    targets: DelegationScopeTarget[];
-    warnings: DelegationScopeWarning[];
+interface DelegationPage<T> {
+    items: T[];
+    page: number;
+    pageSize: number;
+    totalCount: number;
 }
-interface DelegationScopeOperationOption {
+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;
-    permissionCommand: string;
-    displayName: string;
-    isDelegable: boolean;
+    operationKind: string;
+    permissionCommand?: string | null;
+    businessActionCode?: string | null;
     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[];
+    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 DelegationScopeRequestTargetOperation {
+interface DelegationScopeDeniedItem {
+    applicationKey: string;
+    targetType: string;
+    targetKey: string;
     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;
+    permissionCommand?: string;
     reasonCode: string;
-    message: string;
 }
 interface DelegationScopePreview {
     isValid: boolean;
-    normalizedScope?: DelegationScope;
-    summary?: string | null;
+    normalizedScope: DelegationScopeSelection;
+    scopeHash: string;
+    summary: string;
     warnings: DelegationScopeWarning[];
-    deniedItems: DelegationScopePreviewDeniedItem[];
+    deniedItems: DelegationScopeDeniedItem[];
 }
-interface Delegation {
-    id: number;
-    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;
+interface DelegationStatusInfo {
+    effectiveStatus: DelegationEffectiveStatus;
+    reasonCode: string;
     calculatedAtUtc: string;
 }
-interface DelegationStatusHistoryEntry {
-    id: number;
-    fromStatus?: DelegationStatus | null;
-    toStatus: DelegationStatus;
-    fromApprovalStatus?: DelegationApprovalStatus | null;
-    toApprovalStatus?: DelegationApprovalStatus | null;
-    actor: DelegationUser;
-    action: string;
-    reason?: string | null;
-    createdAtUtc: string;
-}
-interface DelegationDetail extends Delegation {
-    statusHistory?: DelegationStatusHistoryEntry[];
+interface DelegationDetail {
+    row: DelegationRow;
+    scope: DelegationScopeSelection;
+    status: DelegationStatusInfo;
 }
-/** Minimal shape returned by login + topbar candidate listing. */
-interface DelegationSummary {
+interface DelegationDto {
     id: number;
-    delegator: DelegationUser;
-    delegatedUser: DelegationUser;
-    status: DelegationStatus;
+    fromUserId: string;
+    toUserId: string;
+    description?: string;
+    isActive?: boolean;
+    delegationDaysType: DelegationDayRuleMode;
+    specificDays: number[];
+    applicationId?: number;
+    requiresApproval?: boolean;
+    effectiveStatus: DelegationEffectiveStatus;
+    statusReasonCode: string;
     allowedActions: DelegationAllowedAction[];
-    startDateUtc: string;
-    endDateUtc: string;
-    scopeSummary?: string;
+    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;
-    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;
+    delegatorUserId?: string;
+    delegatedUserId?: string;
 }
-interface CreateDelegationRequest {
-    delegatedUserId: string;
+interface CreateDelegationLegacyRequest {
+    delegateFrom?: string | null;
+    delegateTo: string;
     description?: string;
-    startDateUtc: string;
-    endDateUtc: string;
-    timeZoneId: string;
-    dayRules: DelegationDayRules;
-    requiresApproval: boolean;
-    scope: DelegationScopeRequest;
+    delegateFromDateTime: string;
+    delegateToDateTime: string;
+    accessibilityIds?: number[];
+    moduleIds?: number[];
+    delegationDaysType: DelegationDayRuleMode;
+    specificDays?: number[];
+    isActive?: boolean;
+    requiresApproval?: boolean;
 }
-interface UpdateDelegationRequest {
-    rowVersion: string;
+interface CreateDelegationV2Request {
+    delegateFrom?: string | null;
+    delegateTo: string;
     description?: string;
-    startDateUtc: string;
-    endDateUtc: string;
-    timeZoneId: string;
-    dayRules: DelegationDayRules;
-    requiresApproval?: boolean;
-    scope: DelegationScopeRequest;
+    delegateFromDateTime: string;
+    delegateToDateTime: string;
+    delegationDaysType: DelegationDayRuleMode;
+    specificDays?: number[];
+    requiresApproval: boolean;
+    scope: DelegationScopeSelection;
 }
+type UpdateDelegationLegacyRequest = CreateDelegationLegacyRequest & {
+    rowVersion: string;
+};
+type UpdateDelegationV2Request = CreateDelegationV2Request & {
+    rowVersion: string;
+};
 interface ApproveDelegationRequest {
     rowVersion: string;
-    comment?: string;
+    reason?: 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",
+    GetMy = "getMy",
+    GetAssigned = "getAssigned",
+    GetActive = "getActive",
+    GetDetail = "getDetail",
     GetScopeOptions = "getScopeOptions",
-    PreviewScope = "previewScope"
+    PreviewScope = "previewScope",
+    Create = "create",
+    Update = "update",
+    Approve = "approve",
+    Reject = "reject",
+    Cancel = "cancel"
 }
 interface DelegationsStateModel extends LoadingStateShape<DelegationsActionKey> {
-    my: PagedResult<Delegation> | null;
-    assigned: PagedResult<Delegation> | null;
-    selected: DelegationDetail | null;
+    my: DelegationPage<DelegationRow> | null;
+    assigned: DelegationPage<DelegationRow> | null;
+    active: DelegationPage<DelegationRow> | null;
+    detail: DelegationDetail | null;
     scopeOptions: DelegationScopeOptions | null;
     scopePreview: DelegationScopePreview | null;
 }
 
 /**
- * Topbar surface for the delegation runtime.
+ * 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: 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.
+ * 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>;
-    /** 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 candidates: _angular_core.Signal<DelegationRow[]>;
     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 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;
-    startCandidate(candidate: DelegationSummary, event: MouseEvent): void;
-    switchTo(candidate: DelegationSummary, event: MouseEvent): void;
+    start(row: DelegationRow, event: MouseEvent): void;
+    switchTo(row: DelegationRow, event: MouseEvent): void;
     endSession(event: MouseEvent): void;
-    private openConfirmation;
+    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>;
 }
@@ -354,28 +252,28 @@ interface StatusVisual {
     styleClass: string;
 }
 declare class DelegationStatusChip {
-    readonly status: _angular_core.InputSignal<DelegationStatus>;
+    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>;
 }
 
 /**
- * Confirmation dialog opened by the topbar menu before starting (or switching to)
- * a delegated session. Calls the facade and closes itself on success.
+ * 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 candidate: _angular_core.InputSignal<DelegationSummary>;
+    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 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">;
+    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, { "candidate": { "alias": "candidate"; "required": true; "isSignal": true; }; "intent": { "alias": "intent"; "required": false; "isSignal": true; }; }, {}, never, never, true, 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 Delegations {
@@ -387,18 +285,12 @@ declare class Delegations {
 
 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.
+ * 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 {
     private readonly facade;
-    private readonly session;
     private readonly modal;
     private readonly transloco;
     protected readonly breadcrumbItems: _angular_core.WritableSignal<({
@@ -420,7 +312,7 @@ declare class DelegationsList implements OnInit {
         label: string;
     }[]>;
     protected readonly isLoading: _angular_core.Signal<boolean>;
-    protected readonly rows: _angular_core.Signal<Delegation[]>;
+    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>>;
@@ -433,8 +325,9 @@ declare class DelegationsList implements OnInit {
     ngOnInit(): void;
     protected switchTab(tab: DelegationTab): void;
     private loadCurrentTab;
-    protected has(row: Delegation, action: DelegationAllowedAction): boolean;
-    protected formatDays(row: Delegation): string;
+    private reloadCurrentTab;
+    protected has(row: DelegationRow, action: DelegationAllowedAction): boolean;
+    protected formatDays(row: DelegationRow): string;
     private viewDetails;
     private openForm;
     private approve;
@@ -447,17 +340,15 @@ declare class DelegationsList implements OnInit {
 }
 
 /**
- * Delegation create/edit form, target-shape compliant.
+ * 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 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.
+ * - 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 {
-    readonly delegationForEdit: _angular_core.InputSignal<Delegation | null>;
+    readonly delegationForEdit: _angular_core.InputSignal<DelegationRow | null>;
     readonly readonly: _angular_core.InputSignal<boolean>;
     private readonly halfWidth;
     private readonly fullWidth;
@@ -467,31 +358,29 @@ declare class DelegationForm implements OnInit {
     private readonly facade;
     delegationFormControl: FormControl<any>;
     formValue: _angular_core.Signal<any>;
-    selected: _angular_core.Signal<_masterteam_delegations.DelegationDetail | null>;
+    detail: _angular_core.Signal<_masterteam_delegations.DelegationDetail | null>;
     isDetailLoading: _angular_core.Signal<boolean>;
     isSaving: _angular_core.Signal<boolean>;
     context: HttpContext;
-    protected readonly isDelegatingToSelf: _angular_core.Signal<boolean>;
-    protected readonly scope: _angular_core.WritableSignal<DelegationScopeRequest>;
+    protected readonly scope: _angular_core.WritableSignal<DelegationScopeSelection>;
     protected readonly specificDaysOptions: _angular_core.WritableSignal<{
         label: string;
         value: number;
     }[]>;
-    protected readonly 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; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-type DetailTab = 'overview' | 'scope' | 'history';
+type DetailTab = 'overview' | 'scope';
 /**
- * Read-only drawer that shows the full server DTO of a delegation, including
- * its status history. Triggered from the row's "View details" action.
+ * Read-only drawer that shows the full `DelegationDetail` ({ row, scope, status }).
  */
 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;
@@ -502,8 +391,8 @@ declare class DelegationDetailDrawer implements OnInit {
     }[];
     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[]>;
+    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;
@@ -511,68 +400,49 @@ declare class DelegationDetailDrawer implements OnInit {
     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;
+interface TargetGroup {
+    key: string;
+    target: DelegationScopeTarget;
+    grants: DelegationGrant[];
 }
 /**
- * Scope picker driven entirely by Identity-provided options.
+ * 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 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`.
+ * `[(scope)]` two-way binds a `DelegationScopeSelection`. The component never
+ * invents permission metadata — it only echoes grants returned by options.
  */
 declare class ScopePicker implements OnInit {
-    /** Two-way bound — the form drives initial value and reads updates back. */
-    readonly scope: _angular_core.ModelSignal<DelegationScopeRequest>;
+    readonly scope: _angular_core.ModelSignal<DelegationScopeSelection>;
     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 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>;
-    /** Set of accordion target keys currently expanded. */
+    /** 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;
-    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;
+    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 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).
+ * 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;
 
@@ -586,25 +456,53 @@ declare class GetAssignedDelegations {
     static readonly type = "[Delegations] Get Assigned Delegations";
     constructor(query?: DelegationListQuery);
 }
-declare class GetDelegation {
+declare class GetActiveAssignedDelegations {
+    query: DelegationListQuery;
+    static readonly type = "[Delegations] Get Active Assigned Delegations";
+    constructor(query?: DelegationListQuery);
+}
+declare class GetDelegationDetail {
     id: number;
-    includeStatusHistory: boolean;
-    static readonly type = "[Delegations] Get Delegation";
-    constructor(id: number, includeStatusHistory?: boolean);
+    static readonly type = "[Delegations] Get Delegation Detail";
+    constructor(id: number);
 }
-declare class ClearSelectedDelegation {
-    static readonly type = "[Delegations] Clear Selected Delegation";
+declare class ClearDelegationDetail {
+    static readonly type = "[Delegations] Clear Delegation Detail";
 }
-declare class CreateDelegation {
-    request: CreateDelegationRequest;
-    static readonly type = "[Delegations] Create Delegation";
-    constructor(request: CreateDelegationRequest);
+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 UpdateDelegation {
+declare class UpdateDelegationLegacy {
     id: number;
-    request: UpdateDelegationRequest;
-    static readonly type = "[Delegations] Update Delegation";
-    constructor(id: number, request: UpdateDelegationRequest);
+    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;
@@ -620,198 +518,163 @@ declare class RejectDelegation {
 }
 declare class CancelDelegation {
     id: number;
-    request: CancelDelegationRequest;
+    rowVersion: string;
+    asAdmin: boolean;
     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";
+    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?: any | null;
+    errors?: ApiErrorBody | null;
     data: T;
-    cacheSession?: string;
+    cacheSession?: string | null;
+    correlationId?: string | null;
 }
 
 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 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>;
-    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>>;
+    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;
-    private applyLifecycleResult;
+    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.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 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.Delegation[]>;
-    readonly assignedItems: _angular_core.Signal<_masterteam_delegations.Delegation[]>;
+    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 isCreating: _angular_core.Signal<boolean>;
-    readonly isUpdating: _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 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>;
+    readonly errorSave: _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>;
+    getActive(query?: DelegationListQuery): rxjs.Observable<void>;
+    getDetail(id: number): rxjs.Observable<void>;
+    clearDetail(): rxjs.Observable<void>;
     loadScopeOptions(delegatorUserId?: string): rxjs.Observable<void>;
-    previewScope(scope: DelegationScopeRequest): 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>;
 }
 
-declare const DELEGATION_SESSION_STORAGE_KEY = "mt.delegation.session.v1";
+/**
+ * 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 {
-    accessToken: string;
-    accessTokenExpiresAtUtc: string;
-    refreshToken: string;
-    refreshTokenExpiresAtUtc: string;
-    delegation: DelegationSummary;
+    token: string;
+    delegation: DelegationRow;
 }
-declare function toActiveSession(pair: DelegationTokenPair): ActiveDelegationSession;
+type DelegationSessionInvalidationReason = 'TokenInvalid' | 'SessionMismatch' | 'ScopeChanged' | 'Forbidden' | 'Logout' | 'UserSwitch' | 'Manual';
 declare enum DelegationSessionActionKey {
-    Bootstrap = "bootstrap",
-    StartSession = "startSession",
-    EndSession = "endSession",
-    RefreshSession = "refreshSession",
-    GetSession = "getSession"
+    LoadCandidates = "loadCandidates",
+    StartSession = "startSession"
 }
 interface DelegationSessionStateModel extends LoadingStateShape<DelegationSessionActionKey> {
     active: ActiveDelegationSession | null;
-    candidates: DelegationSummary[];
+    candidates: DelegationRow[];
 }
 
-/** Reads sessionStorage + login candidates, restores any tab-local active session. */
-declare class BootstrapDelegationSession {
-    static readonly type = "[DelegationSession] Bootstrap";
+/** Fetch the active delegations the current user may start (user/activedelegations). */
+declare class LoadDelegationCandidates {
+    static readonly type = "[DelegationSession] Load Candidates";
 }
-/** 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. */
+/** Start a delegated session for the given assignment row. */
 declare class StartDelegationSession {
-    delegationId: number;
+    delegation: DelegationRow;
     static readonly type = "[DelegationSession] Start";
-    constructor(delegationId: number);
+    constructor(delegation: DelegationRow);
 }
-/** End the current delegated session (server + local). */
+/** End the current delegated session. Client-local only (doc 05). */
 declare class EndDelegationSession {
-    options: {
-        silent?: boolean;
-    };
+    reason: DelegationSessionInvalidationReason;
     static readonly type = "[DelegationSession] End";
-    constructor(options?: {
-        silent?: boolean;
-    });
+    constructor(reason?: DelegationSessionInvalidationReason);
 }
-/** Atomically end current + start another. */
+/** Switch directly from the current session to another delegation. */
 declare class SwitchDelegationSession {
-    delegationId: number;
+    delegation: DelegationRow;
     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');
+    constructor(delegation: DelegationRow);
 }
 
-/**
- * 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 getCandidates(state: DelegationSessionStateModel): DelegationRow[];
     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>;
+    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>;
 }
@@ -819,29 +682,25 @@ declare class DelegationSessionState {
 declare class DelegationSessionFacade {
     private readonly store;
     readonly active: _angular_core.Signal<_masterteam_delegations.ActiveDelegationSession | null>;
-    readonly candidates: _angular_core.Signal<DelegationSummary[]>;
+    readonly candidates: _angular_core.Signal<DelegationRow[]>;
     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>;
+    /** 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 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>;
+    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 { 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 };
+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 };