@f5-sales-demo/pi-resource-management 20.3.2 → 20.4.0

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@f5-sales-demo/pi-resource-management",
-	"version": "20.3.2",
+	"version": "20.4.0",
 	"description": "Shared resource management for F5 XC manifest parsing, validation, diff, and CRUD operations",
 	"homepage": "https://github.com/f5-sales-demo/xcsh",
 	"author": "Robin Mordasiewicz",

package/src/arg-parser.ts

@@ -2,7 +2,7 @@ import type { ParsedExportArgs, ParsedResourceArgs } from "./types";
 
 const VALID_OUTPUT_FORMATS = new Set(["json", "yaml", "table", "wide"]);
 const VALID_EXPORT_FORMATS = new Set(["json", "yaml"]);
-const VALID_DRY_RUN_MODES = new Set(["client", "server"]);
+const VALID_DRY_RUN_MODES = new Set(["client"]);
 
 export function parseResourceArgs(argsString: string): ParsedResourceArgs | { error: string } {
 	const tokens = argsString.split(/\s+/).filter(Boolean);
@@ -11,7 +11,6 @@ export function parseResourceArgs(argsString: string): ParsedResourceArgs | { er
 	let outputFormat: ParsedResourceArgs["outputFormat"] = "table";
 	let dryRun: ParsedResourceArgs["dryRun"];
 	let recursive = false;
-	let force = false;
 	const positionals: string[] = [];
 
 	for (let i = 0; i < tokens.length; i++) {
@@ -44,7 +43,7 @@ export function parseResourceArgs(argsString: string): ParsedResourceArgs | { er
 			if (token.includes("=")) {
 				const mode = token.split("=")[1];
 				if (!VALID_DRY_RUN_MODES.has(mode)) {
-					return { error: `Invalid --dry-run mode: "${mode}". Must be "client" or "server".` };
+					return { error: `Invalid --dry-run mode: "${mode}". Must be "client".` };
 				}
 				dryRun = mode as ParsedResourceArgs["dryRun"];
 			} else {
@@ -52,8 +51,6 @@ export function parseResourceArgs(argsString: string): ParsedResourceArgs | { er
 			}
 		} else if (token === "-R" || token === "--recursive") {
 			recursive = true;
-		} else if (token === "--force") {
-			force = true;
 		} else if (token.startsWith("-")) {
 			return { error: `Unknown flag: "${token}".` };
 		} else {
@@ -67,7 +64,6 @@ export function parseResourceArgs(argsString: string): ParsedResourceArgs | { er
 		outputFormat,
 		dryRun,
 		recursive,
-		force,
 		kind: positionals[0],
 		name: positionals[1],
 	};

package/src/index.ts

@@ -9,6 +9,8 @@ export type { ExportedManifest, ManifestOutputFormat, MinimalExportFilter } from
 export { applyMinimalExportFilter, formatManifestOutput, toManifest, toManifestList } from "./manifest-export";
 export { ManifestParseError, parseManifests } from "./manifest-parser";
 export { formatValidationErrors, validateManifest, validateManifests } from "./manifest-validator";
+export type { RunResourceOperationOptions } from "./operation-runner";
+export { formatResourceOperationReport, readManifestInputs, runResourceOperation } from "./operation-runner";
 export {
 	formatMultiOperationSummary,
 	formatOperationResult,
@@ -26,6 +28,7 @@ export type {
 	HttpTransportRequest,
 	HttpTransportResponse,
 	KindResolver,
+	ManifestOperationInput,
 	ManifestValidationResult,
 	OperationResult,
 	ParsedExportArgs,
@@ -36,6 +39,10 @@ export type {
 	ResourceError,
 	ResourceErrorKind,
 	ResourceManifest,
+	ResourceOperation,
+	ResourceOperationCounts,
+	ResourceOperationItem,
+	ResourceOperationReport,
 	ValidationError,
 	ValidationErrorCode,
 	ValidationWarning,

package/src/manifest-validator.ts

@@ -12,6 +12,7 @@ export function validateManifest(
 	manifest: ResourceManifest,
 	resolver: KindResolver,
 	namespaceOverride?: string,
+	options: { operation?: "create" | "update" | "identity" } = {},
 ): { result: ManifestValidationResult; resolved?: ResolvedKind } {
 	const errors: ValidationError[] = [];
 	const warnings: ValidationWarning[] = [];
@@ -53,15 +54,18 @@ export function validateManifest(
 		}
 	}
 
-	if (resolved?.validation) {
-		const requiredFields = resolved.validation.create ?? resolved.validation.minimum_config ?? [];
+	if (resolved?.validation && options.operation !== "identity") {
+		const requiredFields =
+			options.operation === "update"
+				? (resolved.validation.update ?? resolved.validation.minimum_config ?? [])
+				: (resolved.validation.create ?? resolved.validation.minimum_config ?? []);
 		for (const fieldPath of requiredFields) {
 			if (fieldPath.startsWith("metadata.")) continue;
 			const value = getNestedValue(manifest.rawObject, fieldPath);
 			if (value === undefined || value === null) {
 				errors.push({
 					path: fieldPath,
-					message: `Required field "${fieldPath}" is missing for ${manifest.kind} creation.`,
+					message: `Required field "${fieldPath}" is missing for ${manifest.kind} ${options.operation ?? "create"}.`,
 					code: "MISSING_FIELD",
 				});
 			}
@@ -75,11 +79,12 @@ export function validateManifests(
 	manifests: ResourceManifest[],
 	resolver: KindResolver,
 	namespaceOverride?: string,
+	options: { operation?: "create" | "update" | "identity" } = {},
 ): { results: ManifestValidationResult[]; resolved: (ResolvedKind | undefined)[] } {
 	const results: ManifestValidationResult[] = [];
 	const resolved: (ResolvedKind | undefined)[] = [];
 	for (const manifest of manifests) {
-		const v = validateManifest(manifest, resolver, namespaceOverride);
+		const v = validateManifest(manifest, resolver, namespaceOverride, options);
 		results.push(v.result);
 		resolved.push(v.resolved);
 	}

package/src/operation-runner.ts

@@ -0,0 +1,371 @@
+import { stringify as yamlStringify } from "yaml";
+import { formatDiff } from "./diff-engine";
+import { readManifestFiles } from "./file-reader";
+import { toManifestList } from "./manifest-export";
+import { parseManifests } from "./manifest-parser";
+import { validateManifest } from "./manifest-validator";
+import type { ResourceClient } from "./resource-client";
+import type {
+	KindResolver,
+	ManifestOperationInput,
+	OperationResult,
+	ResourceError,
+	ResourceOperation,
+	ResourceOperationItem,
+	ResourceOperationReport,
+} from "./types";
+
+export interface RunResourceOperationOptions {
+	operation: ResourceOperation;
+	kindResolver: KindResolver;
+	client?: ResourceClient;
+	inputs?: ManifestOperationInput[];
+	kind?: string;
+	name?: string;
+	all?: boolean;
+	namespaceOverride?: string;
+	defaultNamespace?: string;
+	dryRun?: "client";
+}
+
+const MANIFEST_OPERATIONS = new Set<ResourceOperation>(["apply", "create", "update", "delete", "diff", "validate"]);
+
+export async function readManifestInputs(filenames: string[], recursive: boolean): Promise<ManifestOperationInput[]> {
+	const files = await readManifestFiles(filenames, recursive);
+	const inputs: ManifestOperationInput[] = [];
+	let index = 0;
+	for (const file of files) {
+		for (const manifest of parseManifests(file.objects, file.sourcePath)) {
+			inputs.push({ index, sourcePath: file.sourcePath, manifest });
+			index++;
+		}
+	}
+	return inputs;
+}
+
+export async function runResourceOperation(options: RunResourceOperationOptions): Promise<ResourceOperationReport> {
+	if (options.operation === "get" && options.inputs !== undefined) return runManifestGet(options);
+	if (MANIFEST_OPERATIONS.has(options.operation)) return runManifestOperation(options);
+	if (!options.client) return reportForError(options.operation, "API credentials are required for this operation.");
+	if (options.operation === "get") return runGet(options);
+	return runExport(options);
+}
+
+async function runManifestGet(options: RunResourceOperationOptions): Promise<ResourceOperationReport> {
+	const inputs = options.inputs ?? [];
+	if (inputs.length === 0) return reportForError("get", "No resource manifests were provided.");
+
+	const validations = inputs.map(input => {
+		const namespace = options.namespaceOverride ?? input.manifest.metadata.namespace ?? options.defaultNamespace;
+		return validateManifest(input.manifest, options.kindResolver, namespace, { operation: "identity" });
+	});
+	if (validations.some(validation => !validation.result.valid || !validation.resolved)) {
+		return buildReport(
+			"get",
+			inputs.map((input, index) => {
+				const validation = validations[index].result;
+				if (validation.valid && validations[index].resolved) {
+					return itemFromInput(input, options, {
+						status: "skipped",
+						error: validationError("Batch validation failed; no operations were executed."),
+					});
+				}
+				return itemFromInput(input, options, {
+					status: "error",
+					validation,
+					error: validationError(validation.errors.map(error => `${error.path}: ${error.message}`).join("; ")),
+				});
+			}),
+		);
+	}
+	if (!options.client) return reportForError("get", "API credentials are required for this operation.");
+
+	const results: ResourceOperationItem[] = [];
+	for (let index = 0; index < inputs.length; index++) {
+		const input = inputs[index];
+		try {
+			const result = await options.client.get(
+				validations[index].resolved!,
+				input.manifest.metadata.name,
+				options.namespaceOverride ?? input.manifest.metadata.namespace ?? options.defaultNamespace,
+			);
+			results.push(
+				result.error
+					? itemFromInput(input, options, { status: "error", error: result.error })
+					: itemFromInput(input, options, { status: "found", resource: result.resource }),
+			);
+		} catch (error) {
+			results.push(itemFromInput(input, options, { status: "error", error: unexpectedError(error) }));
+		}
+	}
+	return buildReport("get", results);
+}
+
+async function runManifestOperation(options: RunResourceOperationOptions): Promise<ResourceOperationReport> {
+	const inputs = options.inputs ?? [];
+	if (inputs.length === 0) return reportForError(options.operation, "No resource manifests were provided.");
+
+	const validationMode =
+		options.operation === "delete" ? "identity" : options.operation === "update" ? "update" : "create";
+	const validations = inputs.map(input => {
+		const namespace = options.namespaceOverride ?? input.manifest.metadata.namespace ?? options.defaultNamespace;
+		return validateManifest(input.manifest, options.kindResolver, namespace, { operation: validationMode });
+	});
+	const invalid = validations.some(validation => !validation.result.valid || !validation.resolved);
+	if (invalid) {
+		const results = inputs.map((input, index): ResourceOperationItem => {
+			const validation = validations[index].result;
+			if (validation.valid && validations[index].resolved) {
+				return itemFromInput(input, options, {
+					status: "skipped",
+					error: validationError("Batch validation failed; no operations were executed."),
+				});
+			}
+			return itemFromInput(input, options, {
+				status: "error",
+				validation,
+				error: validationError(validation.errors.map(error => `${error.path}: ${error.message}`).join("; ")),
+			});
+		});
+		return buildReport(options.operation, results);
+	}
+
+	if (options.operation === "validate") {
+		return buildReport(
+			options.operation,
+			inputs.map(input => itemFromInput(input, options, { status: "valid" })),
+		);
+	}
+	if (!options.client) return reportForError(options.operation, "API credentials are required for this operation.");
+
+	const results: ResourceOperationItem[] = [];
+	for (let index = 0; index < inputs.length; index++) {
+		const input = inputs[index];
+		const resolved = validations[index].resolved!;
+		try {
+			if (options.operation === "diff") {
+				const diff = await options.client.diff(input.manifest, resolved, options.namespaceOverride);
+				if (diff.error) {
+					results.push(itemFromInput(input, options, { status: "error", error: diff.error }));
+				} else {
+					results.push(
+						itemFromInput(input, options, {
+							status: diff.isNew ? "new" : diff.diff?.hasDifferences ? "different" : "identical",
+							diff: diff.diff,
+							isNew: diff.isNew,
+						}),
+					);
+				}
+				continue;
+			}
+
+			let operationResult: OperationResult;
+			if (options.operation === "apply") {
+				operationResult = await options.client.apply(
+					input.manifest,
+					resolved,
+					options.namespaceOverride,
+					options.dryRun,
+				);
+			} else if (options.operation === "create") {
+				operationResult = await options.client.create(
+					input.manifest,
+					resolved,
+					options.namespaceOverride,
+					options.dryRun,
+				);
+			} else if (options.operation === "update") {
+				operationResult = await options.client.update(
+					input.manifest,
+					resolved,
+					options.namespaceOverride,
+					options.dryRun,
+				);
+			} else {
+				operationResult = await options.client.delete(
+					input.manifest.kind,
+					input.manifest.metadata.name,
+					resolved,
+					options.namespaceOverride ?? input.manifest.metadata.namespace,
+					options.dryRun,
+				);
+			}
+			results.push(operationResultToItem(input, options, operationResult));
+		} catch (error) {
+			results.push(itemFromInput(input, options, { status: "error", error: unexpectedError(error) }));
+		}
+	}
+	return buildReport(options.operation, results);
+}
+
+async function runGet(options: RunResourceOperationOptions): Promise<ResourceOperationReport> {
+	if (!options.kind) return reportForError("get", "A resource kind is required.");
+	try {
+		const resolved = options.kindResolver.resolveKind(options.kind);
+		const result = await options.client!.get(
+			resolved,
+			options.name,
+			options.namespaceOverride ?? options.defaultNamespace,
+		);
+		if (result.error)
+			return buildReport("get", [
+				{ index: 0, kind: options.kind, name: options.name, status: "error", error: result.error },
+			]);
+		return buildReport("get", [
+			{
+				index: 0,
+				kind: options.kind,
+				name: options.name,
+				status: options.name ? "found" : "listed",
+				resource: result.resource,
+				items: result.items,
+			},
+		]);
+	} catch (error) {
+		return reportForError("get", (error as Error).message);
+	}
+}
+
+async function runExport(options: RunResourceOperationOptions): Promise<ResourceOperationReport> {
+	try {
+		if (options.all) {
+			const result = await options.client!.exportAll(
+				options.kindResolver,
+				options.namespaceOverride ?? options.defaultNamespace,
+			);
+			const items: ResourceOperationItem[] = result.manifests.map((manifest, index) => ({
+				index,
+				kind: manifest.kind,
+				name: String(manifest.metadata.name ?? ""),
+				status: "exported",
+				manifest,
+			}));
+			for (const entry of result.errors) {
+				items.push({ index: items.length, kind: entry.kind, status: "error", error: entry.error });
+			}
+			return buildReport("export", items);
+		}
+		if (!options.kind) return reportForError("export", "A resource kind or --all is required.");
+		const resolved = options.kindResolver.resolveKind(options.kind);
+		if (options.name) {
+			const result = await options.client!.exportOne(
+				options.kind,
+				resolved,
+				options.name,
+				options.namespaceOverride ?? options.defaultNamespace,
+			);
+			if (result.error)
+				return buildReport("export", [
+					{ index: 0, kind: options.kind, name: options.name, status: "error", error: result.error },
+				]);
+			return buildReport("export", [
+				{ index: 0, kind: options.kind, name: options.name, status: "exported", manifest: result.manifest },
+			]);
+		}
+		const result = await options.client!.get(
+			resolved,
+			undefined,
+			options.namespaceOverride ?? options.defaultNamespace,
+		);
+		if (result.error)
+			return buildReport("export", [{ index: 0, kind: options.kind, status: "error", error: result.error }]);
+		const manifests = toManifestList({ items: result.items ?? [] }, options.kind);
+		return buildReport(
+			"export",
+			manifests.map((manifest, index) => ({
+				index,
+				kind: options.kind,
+				name: String(manifest.metadata.name ?? ""),
+				status: "exported",
+				manifest,
+			})),
+		);
+	} catch (error) {
+		return reportForError("export", (error as Error).message);
+	}
+}
+
+function operationResultToItem(
+	input: ManifestOperationInput,
+	options: RunResourceOperationOptions,
+	result: OperationResult,
+): ResourceOperationItem {
+	if (result.status === "error") return itemFromInput(input, options, { status: "error", error: result.error });
+	if (result.status === "deleted")
+		return itemFromInput(input, options, { status: result.status, durationMs: result.durationMs });
+	if (result.status === "dry-run")
+		return itemFromInput(input, options, { status: result.status, action: result.action, diff: result.diff });
+	if (result.status === "updated")
+		return itemFromInput(input, options, {
+			status: result.status,
+			durationMs: result.durationMs,
+			resource: result.resource,
+			diff: result.diff,
+		});
+	if (result.status === "created")
+		return itemFromInput(input, options, {
+			status: result.status,
+			durationMs: result.durationMs,
+			resource: result.resource,
+		});
+	return itemFromInput(input, options, { status: result.status, resource: result.resource });
+}
+
+function itemFromInput(
+	input: ManifestOperationInput,
+	options: RunResourceOperationOptions,
+	extra: Partial<ResourceOperationItem> & Pick<ResourceOperationItem, "status">,
+): ResourceOperationItem {
+	return {
+		index: input.index,
+		sourcePath: input.sourcePath,
+		kind: input.manifest.kind,
+		name: input.manifest.metadata.name,
+		namespace: options.namespaceOverride ?? input.manifest.metadata.namespace ?? options.defaultNamespace,
+		...extra,
+	};
+}
+
+function validationError(message: string): ResourceError {
+	return { kind: "validation", message };
+}
+
+function unexpectedError(error: unknown): ResourceError {
+	return { kind: "api", message: error instanceof Error ? error.message : String(error) };
+}
+
+function reportForError(operation: ResourceOperation, message: string): ResourceOperationReport {
+	return buildReport(operation, [{ index: 0, status: "error", error: validationError(message) }]);
+}
+
+function buildReport(operation: ResourceOperation, results: ResourceOperationItem[]): ResourceOperationReport {
+	const failed = results.filter(result => result.status === "error" || result.status === "skipped").length;
+	const counts = {
+		total: results.length,
+		succeeded: results.length - failed,
+		failed,
+	} as ResourceOperationReport["counts"];
+	for (const result of results) counts[result.status] = (counts[result.status] ?? 0) + 1;
+	return { schemaVersion: 1, operation, success: failed === 0, counts, results };
+}
+
+export function formatResourceOperationReport(
+	report: ResourceOperationReport,
+	format: "json" | "yaml" | "table" | "wide" = "table",
+): string {
+	if (format === "json") return JSON.stringify(report, null, 2);
+	if (format === "yaml") return yamlStringify(report);
+	const lines = report.results.map(result => {
+		const identity =
+			result.kind && result.name
+				? `${result.kind}/${result.name}`
+				: (result.kind ?? result.sourcePath ?? "resource");
+		if (result.error) return `${identity} error: ${result.error.message}`;
+		if (result.diff?.hasDifferences) {
+			return `${identity} ${result.status}\n${formatDiff(result.diff, result.kind ?? "resource", result.name ?? "unknown")}`;
+		}
+		return `${identity} ${result.status}`;
+	});
+	lines.push(`${report.counts.succeeded} succeeded, ${report.counts.failed} failed, ${report.counts.total} total`);
+	return lines.join("\n");
+}

package/src/output-formatter.ts

@@ -24,6 +24,9 @@ export function formatOperationResult(
 			if (result.action === "create") {
 				return `${manifest.kind}/${manifest.metadata.name} would be created (dry-run)`;
 			}
+			if (result.action === "delete") {
+				return `${manifest.kind}/${manifest.metadata.name} would be deleted (dry-run)`;
+			}
 			if (result.diff) {
 				return `${manifest.kind}/${manifest.metadata.name} would be updated (dry-run)\n${formatDiff(result.diff, manifest.kind, manifest.metadata.name)}`;
 			}

package/src/resource-client.ts

@@ -117,7 +117,7 @@ export class ResourceClient {
 		manifest: ResourceManifest,
 		resolved: ResolvedKind,
 		namespaceOverride?: string,
-		dryRun?: "client" | "server",
+		dryRun?: "client",
 	): Promise<OperationResult> {
 		const namespace = this.#resolveNamespace(manifest, namespaceOverride);
 		const name = manifest.metadata.name;
@@ -147,7 +147,7 @@ export class ResourceClient {
 		manifest: ResourceManifest,
 		resolved: ResolvedKind,
 		namespaceOverride?: string,
-		dryRun?: "client" | "server",
+		dryRun?: "client",
 	): Promise<OperationResult> {
 		if (dryRun) return { status: "dry-run", action: "create" };
 
@@ -156,12 +156,35 @@ export class ResourceClient {
 		return this.#createResource(manifest, resolved, namespace, startMs);
 	}
 
+	async update(
+		manifest: ResourceManifest,
+		resolved: ResolvedKind,
+		namespaceOverride?: string,
+		dryRun?: "client",
+	): Promise<OperationResult> {
+		const namespace = this.#resolveNamespace(manifest, namespaceOverride);
+		const name = manifest.metadata.name;
+		const getUrl = this.#buildUrl(resolved.paths.get, namespace, name);
+		const startMs = performance.now();
+		const existing = await this.#fetchResource(getUrl);
+
+		if (existing.error) return { status: "error", error: existing.error };
+
+		const diff = this.#computeManifestDiff(existing.body!, manifest);
+		if (!diff.hasDifferences) return { status: "unchanged", resource: existing.body! };
+		if (dryRun) return { status: "dry-run", action: "update", diff };
+		return this.#updateResource(manifest, resolved, namespace, diff, startMs);
+	}
+
 	async delete(
 		kind: string,
 		name: string,
 		resolved: ResolvedKind,
 		namespaceOverride?: string,
+		dryRun?: "client",
 	): Promise<OperationResult> {
+		if (dryRun) return { status: "dry-run", action: "delete" };
+
 		const namespace = namespaceOverride ?? this.#defaultNamespace;
 		const url = this.#buildUrl(resolved.paths.delete, namespace, name);
 
@@ -306,12 +329,7 @@ export class ResourceClient {
 		const result = await this.#fetch(url, "POST", body);
 		const durationMs = Math.round(performance.now() - startMs);
 
-		if (result.error) {
-			if (result.error.httpStatus === 409) {
-				return this.#updateResource(manifest, resolved, namespace, undefined, startMs);
-			}
-			return { status: "error", error: result.error };
-		}
+		if (result.error) return { status: "error", error: result.error };
 
 		return { status: "created", resource: result.body ?? {}, durationMs };
 	}

package/src/types.ts

@@ -58,9 +58,8 @@ export interface ParsedResourceArgs {
 	filenames: string[];
 	namespace?: string;
 	outputFormat: "json" | "yaml" | "table" | "wide";
-	dryRun?: "client" | "server";
+	dryRun?: "client";
 	recursive: boolean;
-	force: boolean;
 	kind?: string;
 	name?: string;
 }
@@ -141,7 +140,7 @@ export type OperationResult =
 	| { status: "unchanged"; resource: Record<string, unknown> }
 	| { status: "deleted"; name: string; kind: string; durationMs: number }
 	| { status: "error"; error: ResourceError }
-	| { status: "dry-run"; action: "create" | "update"; diff?: ResourceDiff };
+	| { status: "dry-run"; action: "create" | "update" | "delete"; diff?: ResourceDiff };
 
 export interface HttpTransportRequest {
 	method: "GET" | "POST" | "PUT" | "DELETE";
@@ -163,11 +162,53 @@ export interface ResourceClientOptions {
 	apiUrl: string;
 	apiToken: string;
 	namespace: string;
-	dryRun?: "client" | "server";
+	dryRun?: "client";
 	resolvePayloadVars?: (json: string) => string;
 	transport?: HttpTransport;
 }
 
+export type ResourceOperation = "apply" | "create" | "update" | "get" | "delete" | "diff" | "export" | "validate";
+
+export interface ManifestOperationInput {
+	index: number;
+	sourcePath: string;
+	manifest: ResourceManifest;
+}
+
+export interface ResourceOperationItem {
+	index: number;
+	sourcePath?: string;
+	kind?: string;
+	name?: string;
+	namespace?: string;
+	status: string;
+	action?: "create" | "update" | "delete";
+	durationMs?: number;
+	resource?: Record<string, unknown>;
+	items?: Record<string, unknown>[];
+	manifest?: { kind: string; metadata: Record<string, unknown>; spec: Record<string, unknown> };
+	manifests?: Array<{ kind: string; metadata: Record<string, unknown>; spec: Record<string, unknown> }>;
+	diff?: ResourceDiff;
+	isNew?: boolean;
+	validation?: ManifestValidationResult;
+	error?: ResourceError;
+}
+
+export interface ResourceOperationCounts {
+	total: number;
+	succeeded: number;
+	failed: number;
+	[status: string]: number;
+}
+
+export interface ResourceOperationReport {
+	schemaVersion: 1;
+	operation: ResourceOperation;
+	success: boolean;
+	counts: ResourceOperationCounts;
+	results: ResourceOperationItem[];
+}
+
 export interface KindResolver {
 	resolveKind(kind: string): ResolvedKind;
 	getAllKnownKinds(): string[];