permdock 0.0.0 → 0.2.0

package/dist/a2a/index.js

@@ -0,0 +1,232 @@
+import { t as compact } from "../compact-y6vfu2_f.js";
+import { n as PermDockDeniedError, t as PermDockApprovalRequiredError } from "../errors-Cz5zn0mW.js";
+import { t as canonicalJson } from "../canonical-json-DemiK4Vp.js";
+import { t as bytesToBase64Url } from "../sha256-BO0swRXL.js";
+import { i as scopesReaching, r as challengeScope } from "../permdock-CzqXjCpU.js";
+import { n as resourceRef } from "../resource-ref-CaS9yVPi.js";
+import { t as mayUse } from "../may-use-DndQ5tQ-.js";
+import { d as wwwAuthenticate, n as bearerChallenge } from "../problem-B43ztKIm.js";
+import { t as instanceOptions } from "../instance-options-Dhhcnm3y.js";
+import { n as createAgentKernel } from "../kernel-GSQnMz3O.js";
+//#region src/a2a/create.ts
+function firstScheme(options) {
+	return Object.keys(options.securitySchemes)[0];
+}
+function skillOf(id, config, scheme) {
+	return {
+		id,
+		name: id,
+		description: config.description ?? config.permission.key,
+		tags: config.tags ?? [config.permission.resource],
+		securityRequirements: scheme === void 0 ? [] : [{ schemes: { [scheme]: { list: [config.permission.scope] } } }]
+	};
+}
+function publicSkills(options) {
+	const scheme = firstScheme(options);
+	return Object.entries(options.skills).map(([id, config]) => skillOf(id, config, scheme));
+}
+function wireScheme(scheme) {
+	switch (scheme.type) {
+		case "oauth2": return { oauth2SecurityScheme: compact({
+			oauth2MetadataUrl: scheme.oauth2MetadataUrl,
+			description: scheme.description
+		}) };
+		case "http": return { httpAuthSecurityScheme: compact({
+			scheme: scheme.scheme,
+			bearerFormat: scheme.bearerFormat,
+			description: scheme.description
+		}) };
+		case "openIdConnect": return { openIdConnectSecurityScheme: compact({
+			openIdConnectUrl: scheme.openIdConnectUrl,
+			description: scheme.description
+		}) };
+		case "mutualTLS": return { mtlsSecurityScheme: compact({ description: scheme.description }) };
+		case "apiKey": return { apiKeySecurityScheme: compact({
+			location: scheme.in,
+			name: scheme.name,
+			description: scheme.description
+		}) };
+		default: return scheme;
+	}
+}
+function cardOf(options, skills) {
+	const info = options.card;
+	return compact({
+		name: info.name,
+		description: info.description ?? info.name,
+		version: info.version,
+		supportedInterfaces: [{
+			url: info.url,
+			protocolBinding: info.protocolBinding ?? "JSONRPC",
+			protocolVersion: "1.0"
+		}],
+		provider: info.provider,
+		documentationUrl: info.documentationUrl,
+		iconUrl: info.iconUrl,
+		capabilities: compact({
+			extendedAgentCard: true,
+			streaming: info.streaming,
+			pushNotifications: info.pushNotifications
+		}),
+		defaultInputModes: info.defaultInputModes ?? DEFAULT_MODES,
+		defaultOutputModes: info.defaultOutputModes ?? DEFAULT_MODES,
+		securitySchemes: Object.fromEntries(Object.entries(options.securitySchemes).map(([name, scheme]) => [name, wireScheme(scheme)])),
+		skills
+	});
+}
+const DEFAULT_MODES = ["text/plain"];
+function delegationOf(auth) {
+	return compact({
+		scopes: auth.scopes,
+		authorizationDetails: auth.extra?.authorizationDetails
+	});
+}
+function actorOf(auth) {
+	return typeof auth.clientId === "string" && auth.clientId !== "" ? {
+		id: auth.clientId,
+		kind: "oauth-client"
+	} : void 0;
+}
+function hasScope(auth, scopes) {
+	return scopes.some((scope) => auth.scopes?.includes(scope) === true);
+}
+const LOAD_FAILED = {
+	outcome: "denied",
+	denials: [{
+		role: null,
+		reason: "validation"
+	}],
+	alternatives: []
+};
+const NO_SUBJECT = {
+	principal: null,
+	context: {}
+};
+function taskStatus(status) {
+	return status === 401 || status === 429 || status === 503 ? status : 403;
+}
+function deniedOutcome(decision, permission, data, subject) {
+	const problem = new PermDockDeniedError({
+		decision,
+		permission: permission.key,
+		scope: permission.scope,
+		resource: resourceRef(permission, data),
+		subject: subject ?? NO_SUBJECT,
+		message: `${permission.key} denied.`
+	}).toProblemDetails();
+	return compact({
+		ok: false,
+		status: taskStatus(problem.status),
+		state: "failed",
+		problem,
+		wwwAuthenticate: wwwAuthenticate(decision, permission, false)
+	});
+}
+function approvalOutcome(decision, permission, data) {
+	return {
+		ok: false,
+		status: 403,
+		state: "input-required",
+		problem: new PermDockApprovalRequiredError({
+			decision,
+			permission: permission.key,
+			scope: permission.scope,
+			resource: resourceRef(permission, data),
+			message: `${permission.key} requires human approval.`
+		}).toProblemDetails()
+	};
+}
+/** A2A 1.0 section 8.4: a detached JWS over the RFC 8785 form of the card. */
+async function signCard(card, signPayload) {
+	const { signatures = [], ...unsigned } = card;
+	const payload = canonicalJson(unsigned);
+	const [header, body, signature, extra] = (await signPayload(payload)).split(".");
+	if (header === void 0 || signature === void 0 || extra !== void 0 || body !== bytesToBase64Url(new TextEncoder().encode(payload))) throw new TypeError("PermDock: an A2A card signer must return a compact JWS over the payload it was given");
+	return {
+		...card,
+		signatures: [...signatures, {
+			protected: header,
+			signature
+		}]
+	};
+}
+function missingScope(permission, scope) {
+	return {
+		ok: false,
+		status: 401,
+		state: "failed",
+		problem: {
+			type: "https://permdock.com/problems/unauthenticated",
+			title: "Insufficient scope",
+			status: 401,
+			detail: `insufficient_scope: ${scope}`,
+			permission: permission.key,
+			scope
+		},
+		wwwAuthenticate: bearerChallenge({
+			error: "insufficient_scope",
+			scopes: [scope]
+		})
+	};
+}
+function createPermDock(policy, options) {
+	for (const [id, config] of Object.entries(options.skills)) if (config.permission.kind === "instance" && config.data === void 0) throw new TypeError(`PermDock: A2A skill '${id}' checks ${config.permission.key} on a row and needs a data loader; the task body is never used as the row`);
+	const kernel = createAgentKernel(policy, compact({
+		subject: options.subject,
+		actor: actorOf,
+		delegation: delegationOf,
+		tenant: options.tenant,
+		store: options.store,
+		adapter: "a2a",
+		...instanceOptions(options)
+	}));
+	const agentCard = () => cardOf(options, publicSkills(options));
+	const extendedAgentCard = async (auth) => {
+		let permdock;
+		try {
+			permdock = await kernel.instance(auth);
+		} catch {
+			return cardOf(options, []);
+		}
+		const scheme = firstScheme(options);
+		const skills = [];
+		for (const [id, config] of Object.entries(options.skills)) if (mayUse(permdock, config.permission)) skills.push(skillOf(id, config, scheme));
+		return cardOf(options, skills);
+	};
+	const protectSkill = (selector) => async (task, auth) => {
+		const id = selector(task);
+		const config = Object.hasOwn(options.skills, id) ? options.skills[id] : void 0;
+		if (config === void 0) return {
+			ok: false,
+			status: 403,
+			state: "failed",
+			problem: {
+				type: "https://permdock.com/problems/denied",
+				title: "Permission denied",
+				status: 403,
+				detail: "unknown skill"
+			}
+		};
+		if (!hasScope(auth, scopesReaching(policy, config.permission))) return missingScope(config.permission, challengeScope(policy, config.permission));
+		const checked = await kernel.check(compact({
+			permission: config.permission,
+			data: config.data
+		}), task, auth, compact({ resumeToken: auth.extra?.approval }));
+		if (!checked.ok) return deniedOutcome(LOAD_FAILED, config.permission, void 0, checked.permdock?.subject);
+		const { decision, data, permdock } = checked;
+		switch (decision.outcome) {
+			case "granted": return { ok: true };
+			case "denied": return deniedOutcome(decision, config.permission, data, permdock.subject);
+			case "approval-required": return approvalOutcome(decision, config.permission, data);
+			default: return decision;
+		}
+	};
+	return {
+		agentCard,
+		extendedAgentCard,
+		protectSkill,
+		sign: signCard
+	};
+}
+//#endregion
+export { createPermDock };

package/dist/adapter-context-mlWsVGGg.js

@@ -0,0 +1,23 @@
+import { n as isActor } from "./subject-C6dLxqHU.js";
+//#region src/core/adapter-context.ts
+/** Resolves an adapter `tenant` option against its framework context; a throw is no tenant. */
+async function tenantScope(option, context) {
+	if (option === void 0 || typeof option === "string") return { tenant: option };
+	try {
+		return { tenant: await option(context) };
+	} catch {
+		return { tenant: void 0 };
+	}
+}
+/** Resolves an adapter `actor` option; anything but an `Actor`, or a throw, is no actor. */
+async function actorFrom(option, context) {
+	if (option === void 0) return;
+	try {
+		const resolved = await option(context);
+		return isActor(resolved) ? resolved : void 0;
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { tenantScope as n, actorFrom as t };

package/dist/ai-sdk/index.d.ts

@@ -0,0 +1,95 @@
+import { C as Policy, Nr as Principal, kr as Delegation } from "../policy-CFZAr_Al.js";
+import { f as Permission } from "../permissions-DttnqqxC.js";
+import { f as ApprovalStore } from "../types-vKyAMtcX.js";
+import { t as InstanceOptions } from "../instance-options-BK_rNOSC.js";
+import { t as ToolMap } from "../types-Bvc4oWT6.js";
+//#region src/ai-sdk/create.d.ts
+type AiSdkContext = {
+  readonly runtimeContext?: unknown;
+  readonly permdockApproval?: string;
+  readonly [key: string]: unknown;
+};
+type AiSdkPermDockOptions<TUser = unknown> = InstanceOptions & {
+  readonly subject: (context: AiSdkContext) => TUser | Promise<TUser>;
+  readonly actor?: (context: AiSdkContext) => unknown;
+  readonly delegation?: (context: AiSdkContext) => Delegation | undefined | Promise<Delegation | undefined>;
+  readonly tenant?: string | ((context: AiSdkContext) => string | undefined | Promise<string | undefined>);
+  readonly tools: ToolMap;
+  readonly store?: ApprovalStore;
+  /**
+   * Tools the `tools` map does not bind to a permission. `'deny'` (default):
+   * the middleware hides them and `toolApproval` denies them. `'allow'`: they
+   * pass through both, to the application's own `toolApproval`.
+   */
+  readonly unmapped?: "deny" | "allow";
+};
+/** What an AI SDK tool approval function may return; `undefined` is `not-applicable`. */
+type ToolApprovalResult = ToolApprovalStatus | undefined | "not-applicable" | "denied" | "user-approval" | {
+  readonly type: "not-applicable";
+} | {
+  readonly type: "approved";
+  readonly reason?: string;
+} | {
+  readonly type: "denied";
+  readonly reason?: string;
+} | {
+  readonly type: "user-approval";
+  readonly reason?: string;
+};
+/** An application's own tool approval function, in the AI SDK's generic form. */
+type AppToolApproval = (call: ToolApprovalCall) => ToolApprovalResult | PromiseLike<ToolApprovalResult>;
+type ToolApprovalStatus = "approved" | {
+  readonly type: "denied";
+  readonly reason: string;
+} | {
+  readonly type: "user-approval";
+  readonly reason: string;
+  readonly token: string;
+};
+/** Structural `GenericToolApprovalFunction` options from `ai`. */
+type ToolApprovalCall = {
+  readonly toolCall: {
+    readonly toolName: string;
+    readonly toolCallId?: string;
+    readonly input?: unknown;
+  };
+  readonly messages?: readonly unknown[];
+  readonly runtimeContext?: unknown;
+};
+/** Structural `ToolNeedsApprovalFunction` options from `ai`. */
+type NeedsApprovalOptions = {
+  readonly toolCallId?: string;
+  readonly messages?: readonly unknown[];
+  readonly context?: unknown;
+};
+type CallParams = {
+  readonly tools?: readonly {
+    readonly name?: string;
+  }[];
+  readonly toolChoice?: unknown;
+};
+/** Structural `LanguageModelMiddleware` (specification `v4`) from `ai`. */
+type LanguageModelMiddleware = {
+  readonly specificationVersion: "v4";
+  readonly transformParams: <TParams extends CallParams>(options: {
+    readonly params: TParams;
+  }) => Promise<TParams>;
+};
+type AiSdkPermDock = {
+  readonly toolApproval: (call: ToolApprovalCall) => Promise<ToolApprovalStatus>;
+  /**
+   * PermDock's `toolApproval` followed by the application's own: `app` is
+   * asked only for a call PermDock grants (or an unmapped tool under
+   * `unmapped: 'allow'`), and its answer is returned as is, `undefined`
+   * included (not applicable, as the AI SDK reads it). An answer that is not
+   * a tool approval result denies. PermDock's denials and approval requests
+   * come first.
+   */
+  readonly composeToolApproval: (app: AppToolApproval) => (call: ToolApprovalCall) => Promise<ToolApprovalResult>;
+  /** Hides tools the subject in `context` can never use, before the model sees them. */
+  readonly capabilityMiddleware: (context: AiSdkContext) => LanguageModelMiddleware;
+  readonly needsApproval: (permission: Permission) => (input: unknown, options?: NeedsApprovalOptions) => Promise<boolean>;
+};
+export declare function createPermDock<TUser, TPrincipal extends Principal = Principal>(policy: Policy<TUser, TPrincipal>, options: AiSdkPermDockOptions<TUser>): AiSdkPermDock;
+//#endregion
+export type { AiSdkContext, AiSdkPermDock, AiSdkPermDockOptions, AppToolApproval, LanguageModelMiddleware, NeedsApprovalOptions, ToolApprovalCall, ToolApprovalResult, ToolApprovalStatus };

package/dist/ai-sdk/index.js

@@ -0,0 +1,154 @@
+import { t as compact } from "../compact-y6vfu2_f.js";
+import { n as PermDockDeniedError, t as PermDockApprovalRequiredError } from "../errors-Cz5zn0mW.js";
+import { t as instanceOptions } from "../instance-options-Dhhcnm3y.js";
+import { n as createAgentKernel, t as approvalTokenOf } from "../kernel-GSQnMz3O.js";
+//#region src/ai-sdk/create.ts
+const APPROVAL_STATUSES = /* @__PURE__ */ new Set([
+	"approved",
+	"not-applicable",
+	"denied",
+	"user-approval"
+]);
+function isToolApprovalResult(value) {
+	if (value === void 0 || APPROVAL_STATUSES.has(value)) return true;
+	return typeof value === "object" && value !== null && "type" in value && APPROVAL_STATUSES.has(value.type) && (!("reason" in value) || value.reason === void 0 || typeof value.reason === "string");
+}
+function contextOf(call) {
+	const runtime = call.runtimeContext !== null && typeof call.runtimeContext === "object" ? call.runtimeContext : {};
+	return compact({
+		...runtime,
+		runtimeContext: call.runtimeContext
+	});
+}
+function toolContextOf(options) {
+	const tool = options.context !== null && typeof options.context === "object" ? options.context : {};
+	return compact({
+		...tool,
+		toolContext: options.context
+	});
+}
+/**
+* Whether `messages` already carry an approval request for `toolCallId`: the
+* SDK is re-checking a call a user approved, and treats any answer other
+* than `denied` as approval.
+*/
+function isRecheck(messages, toolCallId) {
+	if (!Array.isArray(messages) || typeof toolCallId !== "string") return false;
+	return messages.some((message) => {
+		if (typeof message !== "object" || message === null) return false;
+		const { role, content } = message;
+		return role === "assistant" && Array.isArray(content) && content.some((part) => typeof part === "object" && part !== null && part.type === "tool-approval-request" && part.toolCallId === toolCallId);
+	});
+}
+function resourceOf(permission, data) {
+	const id = typeof data === "object" && data !== null ? data.id : void 0;
+	return typeof id === "string" || typeof id === "number" ? {
+		type: permission.resource,
+		id: String(id)
+	} : { type: permission.resource };
+}
+function deniedError(verdict, permission, permdock) {
+	return new PermDockDeniedError({
+		decision: verdict.decision ?? {
+			outcome: "denied",
+			denials: [],
+			alternatives: []
+		},
+		permission: permission.key,
+		scope: permission.scope,
+		resource: { type: permission.resource },
+		subject: permdock.subject,
+		message: verdict.reason
+	});
+}
+function createPermDock(policy, options) {
+	const kernel = createAgentKernel(policy, {
+		...compact({
+			actor: options.actor,
+			delegation: options.delegation,
+			tenant: options.tenant,
+			store: options.store
+		}),
+		...instanceOptions(options),
+		subject: options.subject,
+		tools: options.tools,
+		adapter: "ai-sdk"
+	});
+	const byPermission = /* @__PURE__ */ new Map();
+	for (const [name, binding] of Object.entries(options.tools)) byPermission.set(binding.permission.key, name);
+	const passes = (toolName) => options.unmapped === "allow" && !Object.hasOwn(options.tools, toolName);
+	const decide = (toolName, args, context) => kernel.decideTool(toolName, args, context, compact({ resumeToken: approvalTokenOf(context) }));
+	const toolApproval = async (call) => {
+		if (passes(call.toolCall.toolName)) return "approved";
+		const context = contextOf(call);
+		const verdict = await decide(call.toolCall.toolName, call.toolCall.input, context);
+		if (verdict.outcome === "granted") return "approved";
+		if (verdict.outcome === "denied") return {
+			type: "denied",
+			reason: verdict.reason
+		};
+		if (isRecheck(call.messages, call.toolCall.toolCallId)) return {
+			type: "denied",
+			reason: `${verdict.summary} No approval is recorded for this call.`
+		};
+		return {
+			type: "user-approval",
+			reason: verdict.summary,
+			token: verdict.token
+		};
+	};
+	const capabilityMiddleware = (context) => ({
+		specificationVersion: "v4",
+		transformParams: async ({ params }) => {
+			if (params.tools === void 0) return params;
+			const allowed = await kernel.allowedToolNames(context);
+			const keeps = (name) => typeof name === "string" && (allowed.has(name) || passes(name));
+			const tools = params.tools.filter((tool) => keeps(tool.name));
+			const choice = params.toolChoice;
+			const forcedAway = choice?.type === "tool" && !keeps(choice.toolName);
+			return {
+				...params,
+				tools,
+				...forcedAway ? { toolChoice: { type: "none" } } : {}
+			};
+		}
+	});
+	const needsApproval = (permission) => async (input, needsOptions = {}) => {
+		const context = toolContextOf(needsOptions);
+		const toolName = byPermission.get(permission.key);
+		if (toolName === void 0) throw deniedError({
+			outcome: "denied",
+			decision: null,
+			permission,
+			reason: `${permission.key} is not bound to a tool.`
+		}, permission, await kernel.instance(context));
+		const verdict = await decide(toolName, input, context);
+		if (verdict.outcome === "granted") return false;
+		if (verdict.outcome === "denied") throw deniedError(verdict, permission, await kernel.instance(context));
+		if (isRecheck(needsOptions.messages, needsOptions.toolCallId)) throw new PermDockApprovalRequiredError({
+			decision: verdict.decision,
+			permission: permission.key,
+			scope: permission.scope,
+			resource: resourceOf(permission, verdict.data),
+			message: `${verdict.summary} No approval is recorded for this call.`
+		});
+		return true;
+	};
+	const composeToolApproval = (app) => async (call) => {
+		const verdict = await toolApproval(call);
+		if (verdict !== "approved") return verdict;
+		const answer = await app(call);
+		return isToolApprovalResult(answer) ? answer : {
+			type: "denied",
+			reason: "The tool approval answer was not valid."
+		};
+	};
+	return {
+		toolApproval,
+		composeToolApproval,
+		capabilityMiddleware,
+		needsApproval
+	};
+}
+//#endregion
+export { createPermDock };

package/dist/approval-required-TzNB9oQA.js

@@ -0,0 +1,6 @@
+//#region src/core/approval-required.ts
+function requiresApproval(approval) {
+	return approval !== void 0;
+}
+//#endregion
+export { requiresApproval as t };

package/dist/approvals/index.d.ts

@@ -0,0 +1,3 @@
+import { _ as approverRelationKey, a as ApprovalListFilter, c as ApprovalRequest, d as ApprovalStatus, f as ApprovalStore, g as approvalQuorum, h as DEFAULT_APPROVAL_TTL_MS, i as ApprovalInspectResult, l as ApprovalResumeFailure, m as ApprovalVerdict, n as ApprovalApprovers, o as ApprovalListQuery, p as ApprovalSubjectSummary, r as ApprovalCancelMeta, s as ApprovalPage, t as APPROVAL_HEADER, u as ApprovalSignature, v as escalationOpenAt } from "../types-vKyAMtcX.js";
+import { C as ApproverRelationsOptions, D as ApprovalError, E as approvalsHandler, O as ApprovalErrorCode, S as vouchApproval, T as ApprovalsHandlerOptions, _ as resolveApproval, a as approverPermissions, b as storedApprovalToken, c as decodeApprovalCursor, d as pageApprovals, f as cancelApprovals, g as requestApproval, h as readApprovalHeader, i as memoryApprovalStore, k as isApprovalError, l as encodeApprovalCursor, m as inspectApproval, n as applyApprovalVerdict, o as ApprovalCursorPosition, p as consumeApproval, r as assertApprover, s as approvalPageSize, t as MemoryApprovalStore, u as listAllApprovals, v as resumeDecision, w as approverRelations, x as summariseSubject, y as resumeFromHeader } from "../index-D6_cSa1z.js";
+export { APPROVAL_HEADER, type ApprovalApprovers, type ApprovalCancelMeta, type ApprovalCursorPosition, ApprovalError, type ApprovalErrorCode, type ApprovalInspectResult, type ApprovalListFilter, type ApprovalListQuery, type ApprovalPage, type ApprovalRequest, type ApprovalResumeFailure, type ApprovalSignature, type ApprovalStatus, type ApprovalStore, type ApprovalSubjectSummary, type ApprovalVerdict, type ApprovalsHandlerOptions, type ApproverRelationsOptions, DEFAULT_APPROVAL_TTL_MS, type MemoryApprovalStore, applyApprovalVerdict, approvalPageSize, approvalQuorum, approvalsHandler, approverPermissions, approverRelationKey, approverRelations, assertApprover, cancelApprovals, consumeApproval, decodeApprovalCursor, encodeApprovalCursor, escalationOpenAt, inspectApproval, isApprovalError, listAllApprovals, memoryApprovalStore, pageApprovals, readApprovalHeader, requestApproval, resolveApproval, resumeDecision, resumeFromHeader, storedApprovalToken, summariseSubject, vouchApproval };

package/dist/approvals/index.js

@@ -0,0 +1,5 @@
+import { n as isApprovalError, t as ApprovalError } from "../errors-DRnGZHzF.js";
+import { a as decodeApprovalCursor, c as pageApprovals, d as approvalQuorum, f as approverRelationKey, i as approvalPageSize, l as APPROVAL_HEADER, n as assertApprover, o as encodeApprovalCursor, p as escalationOpenAt, r as memoryApprovalStore, s as listAllApprovals, t as applyApprovalVerdict, u as DEFAULT_APPROVAL_TTL_MS } from "../store-DMAWwAJV.js";
+import { a as requestApproval, c as resumeFromHeader, d as vouchApproval, f as approverPermissions, i as readApprovalHeader, l as storedApprovalToken, m as approverRelations, n as consumeApproval, o as resolveApproval, r as inspectApproval, s as resumeDecision, t as cancelApprovals, u as summariseSubject } from "../helpers-H_KARDVC.js";
+import { t as approvalsHandler } from "../approvals-DbYAuNkG.js";
+export { APPROVAL_HEADER, ApprovalError, DEFAULT_APPROVAL_TTL_MS, applyApprovalVerdict, approvalPageSize, approvalQuorum, approvalsHandler, approverPermissions, approverRelationKey, approverRelations, assertApprover, cancelApprovals, consumeApproval, decodeApprovalCursor, encodeApprovalCursor, escalationOpenAt, inspectApproval, isApprovalError, listAllApprovals, memoryApprovalStore, pageApprovals, readApprovalHeader, requestApproval, resolveApproval, resumeDecision, resumeFromHeader, storedApprovalToken, summariseSubject, vouchApproval };