@prismatic-io/components-adobe-experience-manager 0.0.0-stage → 0.0.1

package/npm-dist/index.cjs

@@ -0,0 +1,4466 @@
+let _prismatic_io_spectral = require("@prismatic-io/spectral");
+let _prismatic_io_spectral_http = require("@prismatic-io/spectral/http");
+let node_dns = require("node:dns");
+let node_https = require("node:https");
+let node_net = require("node:net");
+let node_crypto = require("node:crypto");
+//#region src/constants.ts
+const SERVER_TO_SERVER_CONNECTION_KEY = "aemOAuthServerToServer";
+const WEB_APP_CONNECTION_KEY = "aemOAuthWebApp";
+const DEFAULT_TOKEN_URL = "https://ims-na1.adobelogin.com/ims/token/v3";
+const DEFAULT_AUTHORIZE_URL = "https://ims-na1.adobelogin.com/ims/authorize/v2";
+const WEB_APP_DEFAULT_SCOPES = "openid,AdobeID,aem.assets.author,aem.folders";
+const AEM_HOST_SUFFIX = ".adobeaemcloud.com";
+const SITES_API_PATH = "/adobe/sites";
+const FOLDERS_API_PATH = "/adobe/folders";
+const ASSETS_API_PATH = "/adobe/assets";
+const IO_EVENTS_BASE_URL = "https://api.adobe.io/events";
+const IO_EVENTS_PUBLIC_KEY_BASE_URL = "https://static.adobeioevents.com";
+const DEFAULT_DAM_ROOT = "/content/dam";
+const RETRYABLE_STATUS_CODES = [429, 503];
+const SETTLE_LAG_MS = 120 * 1e3;
+const MAX_FOLDER_WALK = 1e3;
+const MAX_DATA_SOURCE_ITEMS = 1e3;
+const ASSET_MODIFY_DATE_FIELD = "repositoryMetadata.repo:modifyDate";
+const ASSET_CREATE_DATE_FIELD = "repositoryMetadata.repo:createDate";
+const ASSET_ANCESTORS_FIELD = "repositoryMetadata.repo:ancestors";
+const ASSET_FORMAT_FIELD = "repositoryMetadata.dc:format";
+const CONTENT_FRAGMENT_STATUSES = [
+	{
+		label: "New",
+		value: "NEW"
+	},
+	{
+		label: "Draft",
+		value: "DRAFT"
+	},
+	{
+		label: "Published",
+		value: "PUBLISHED"
+	},
+	{
+		label: "Modified",
+		value: "MODIFIED"
+	},
+	{
+		label: "Unpublished",
+		value: "UNPUBLISHED"
+	}
+];
+const DEFAULT_TRIGGER_FRAGMENT_STATUSES = ["PUBLISHED", "MODIFIED"];
+const CONTENT_FRAGMENT_PROJECTIONS = [
+	{
+		label: "Minimal",
+		value: "minimal"
+	},
+	{
+		label: "Summary",
+		value: "summary"
+	},
+	{
+		label: "Full",
+		value: "full"
+	}
+];
+const CONTENT_FRAGMENT_REFERENCES = [
+	{
+		label: "Direct",
+		value: "direct"
+	},
+	{
+		label: "Direct (Hydrated)",
+		value: "direct-hydrated"
+	},
+	{
+		label: "All",
+		value: "all"
+	},
+	{
+		label: "All (Hydrated)",
+		value: "all-hydrated"
+	}
+];
+const CONTENT_FRAGMENT_SORT_FIELDS = [
+	{
+		label: "Title",
+		value: "title"
+	},
+	{
+		label: "Created",
+		value: "created"
+	},
+	{
+		label: "Modified",
+		value: "modified"
+	},
+	{
+		label: "Modified or Created",
+		value: "modifiedOrCreated"
+	}
+];
+const SORT_ORDERS = [{
+	label: "Ascending",
+	value: "ASC"
+}, {
+	label: "Descending",
+	value: "DESC"
+}];
+const FOLDER_LISTING_TYPES = [
+	{
+		label: "Folders and Assets",
+		value: "FOLDER,ASSET"
+	},
+	{
+		label: "Folders",
+		value: "FOLDER"
+	},
+	{
+		label: "Assets",
+		value: "ASSET"
+	}
+];
+const FOLDER_ORDER_BY = [
+	{
+		label: "Name",
+		value: "name"
+	},
+	{
+		label: "Size",
+		value: "size"
+	},
+	{
+		label: "Last Modified",
+		value: "lastModifiedAt"
+	}
+];
+const ASSET_SORT_FIELDS = [
+	{
+		label: "Modified",
+		value: ASSET_MODIFY_DATE_FIELD
+	},
+	{
+		label: "Created",
+		value: ASSET_CREATE_DATE_FIELD
+	},
+	{
+		label: "Name",
+		value: "repositoryMetadata.repo:name"
+	}
+];
+const AEM_EVENT_BRANCHES = ["Notification", "URL Verification"];
+const AEM_SITES_EVENT_TYPES = [
+	{
+		label: "Content Fragment Created",
+		value: "aem.sites.contentFragment.created"
+	},
+	{
+		label: "Content Fragment Modified",
+		value: "aem.sites.contentFragment.modified"
+	},
+	{
+		label: "Content Fragment Published",
+		value: "aem.sites.contentFragment.published"
+	},
+	{
+		label: "Content Fragment Unpublished",
+		value: "aem.sites.contentFragment.unpublished"
+	},
+	{
+		label: "Content Fragment Deleted",
+		value: "aem.sites.contentFragment.deleted"
+	},
+	{
+		label: "Page Created",
+		value: "aem.sites.page.created"
+	},
+	{
+		label: "Page Modified",
+		value: "aem.sites.page.modified"
+	},
+	{
+		label: "Page Published",
+		value: "aem.sites.page.published"
+	},
+	{
+		label: "Page Unpublished",
+		value: "aem.sites.page.unpublished"
+	},
+	{
+		label: "Page Deleted",
+		value: "aem.sites.page.deleted"
+	}
+];
+const AEM_ASSETS_EVENT_TYPES = [
+	{
+		label: "Asset Processing Completed",
+		value: "aem.assets.asset.processing_completed"
+	},
+	{
+		label: "Asset Metadata Updated",
+		value: "aem.assets.asset.metadata_updated"
+	},
+	{
+		label: "Asset Published",
+		value: "aem.assets.asset.published"
+	},
+	{
+		label: "Asset Unpublished",
+		value: "aem.assets.asset.unpublished"
+	},
+	{
+		label: "Asset Deleted",
+		value: "aem.assets.asset.deleted"
+	}
+];
+const DATE_ONLY_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/;
+//#endregion
+//#region src/connections/aemOAuthServerToServer.ts
+const aemOAuthServerToServer = (0, _prismatic_io_spectral.oauth2Connection)({
+	key: SERVER_TO_SERVER_CONNECTION_KEY,
+	display: {
+		label: "OAuth 2.0 Client Credentials",
+		description: "Authenticate to AEM as a Cloud Service with an OAuth Server-to-Server credential from the Adobe Developer Console."
+	},
+	oauth2Type: _prismatic_io_spectral.OAuth2Type.ClientCredentials,
+	inputs: {
+		aemHost: {
+			label: "AEM Author Host",
+			placeholder: "Enter AEM author host",
+			type: "string",
+			required: true,
+			shown: true,
+			comments: "The host name of the AEM as a Cloud Service author environment, without https://. Shown in Cloud Manager as the author URL.",
+			example: "author-p12345-e123456.adobeaemcloud.com"
+		},
+		clientId: {
+			label: "Client ID",
+			placeholder: "Enter client ID",
+			type: "string",
+			required: true,
+			shown: true,
+			comments: "The Client ID of the OAuth Server-to-Server credential in the [Adobe Developer Console](https://developer.adobe.com/console) project. Also sent as the X-Api-Key header.",
+			example: "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6"
+		},
+		clientSecret: {
+			label: "Client Secret",
+			placeholder: "Enter client secret",
+			type: "password",
+			required: true,
+			shown: true,
+			comments: "The Client Secret of the OAuth Server-to-Server credential in the Adobe Developer Console project."
+		},
+		scopes: {
+			label: "Scopes",
+			placeholder: "Enter scopes",
+			type: "string",
+			required: true,
+			shown: true,
+			comments: "The space or comma separated scopes listed on the OAuth Server-to-Server credential in the Adobe Developer Console. Copy them exactly as shown.",
+			example: "openid, AdobeID"
+		},
+		tokenUrl: {
+			label: "Token URL",
+			placeholder: "Enter token URL",
+			type: "string",
+			required: true,
+			shown: true,
+			comments: "The Adobe IMS token endpoint. Change only when Adobe directs a different region.",
+			example: DEFAULT_TOKEN_URL,
+			default: DEFAULT_TOKEN_URL
+		}
+	}
+});
+//#endregion
+//#region src/connections/aemOAuthWebApp.ts
+const aemOAuthWebApp = (0, _prismatic_io_spectral.oauth2Connection)({
+	key: WEB_APP_CONNECTION_KEY,
+	display: {
+		label: "OAuth 2.0",
+		description: "Authenticate to AEM as a Cloud Service as an Adobe user with an OAuth Web App credential from the Adobe Developer Console. Requests run with that user's AEM permissions."
+	},
+	oauth2Type: _prismatic_io_spectral.OAuth2Type.AuthorizationCode,
+	inputs: {
+		aemHost: {
+			label: "AEM Author Host",
+			placeholder: "Enter AEM author host",
+			type: "string",
+			required: true,
+			shown: true,
+			comments: "The host name of the AEM as a Cloud Service author environment, without https://. Shown in Cloud Manager as the author URL.",
+			example: "author-p12345-e123456.adobeaemcloud.com"
+		},
+		clientId: {
+			label: "Client ID",
+			placeholder: "Enter client ID",
+			type: "string",
+			required: true,
+			shown: true,
+			comments: "The Client ID of the OAuth Web App credential in the [Adobe Developer Console](https://developer.adobe.com/console) project. Also sent as the X-Api-Key header.",
+			example: "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6"
+		},
+		clientSecret: {
+			label: "Client Secret",
+			placeholder: "Enter client secret",
+			type: "password",
+			required: true,
+			shown: true,
+			comments: "The Client Secret of the OAuth Web App credential in the Adobe Developer Console project."
+		},
+		scopes: {
+			label: "Scopes",
+			placeholder: "Enter scopes",
+			type: "string",
+			required: true,
+			shown: true,
+			comments: "The comma separated scopes to request, exactly as the credential's Scopes tab in the Adobe Developer Console lists them. Adobe rejects the authorization when a scope the credential does not list is requested.",
+			example: WEB_APP_DEFAULT_SCOPES,
+			default: WEB_APP_DEFAULT_SCOPES
+		},
+		authorizeUrl: {
+			label: "Authorize URL",
+			placeholder: "Enter authorize URL",
+			type: "string",
+			required: true,
+			shown: true,
+			comments: "The Adobe IMS authorization endpoint. Change only when Adobe directs a different region.",
+			example: DEFAULT_AUTHORIZE_URL,
+			default: DEFAULT_AUTHORIZE_URL
+		},
+		tokenUrl: {
+			label: "Token URL",
+			placeholder: "Enter token URL",
+			type: "string",
+			required: true,
+			shown: true,
+			comments: "The Adobe IMS token endpoint. Change only when Adobe directs a different region.",
+			example: DEFAULT_TOKEN_URL,
+			default: DEFAULT_TOKEN_URL
+		}
+	}
+});
+//#endregion
+//#region src/connections/index.ts
+var connections_default = [aemOAuthServerToServer, aemOAuthWebApp];
+//#endregion
+//#region src/utils/network.ts
+const blockedRanges = new node_net.BlockList();
+for (const [network, prefix] of [
+	["0.0.0.0", 8],
+	["10.0.0.0", 8],
+	["100.64.0.0", 10],
+	["127.0.0.0", 8],
+	["169.254.0.0", 16],
+	["172.16.0.0", 12],
+	["192.0.0.0", 24],
+	["192.168.0.0", 16],
+	["198.18.0.0", 15],
+	["224.0.0.0", 4],
+	["240.0.0.0", 4]
+]) blockedRanges.addSubnet(network, prefix, "ipv4");
+for (const [network, prefix] of [
+	["::", 128],
+	["::1", 128],
+	["fc00::", 7],
+	["fe80::", 10],
+	["ff00::", 8]
+]) blockedRanges.addSubnet(network, prefix, "ipv6");
+const assertPublicUrl = (url) => {
+	const parsed = new URL(url);
+	if (parsed.protocol !== "https:") throw new Error(`Only https:// URLs may be fetched. Received: ${url}`);
+	if (isBlockedAddress(parsed.hostname.replace(/^\[|\]$/g, ""))) throw new Error(`Refusing to fetch a non-public address: ${parsed.hostname}`);
+};
+const guardedLookup = (hostname, options, callback) => {
+	(0, node_dns.lookup)(hostname, {
+		...options,
+		all: true
+	}, (error, addresses) => {
+		if (error) return callback(error, "", 0);
+		const resolved = addresses;
+		if (resolved.find((entry) => isBlockedAddress(entry.address)) || !resolved.length) return callback(/* @__PURE__ */ new Error(`Refusing to fetch ${hostname}: it resolves to a non-public address.`), "", 0);
+		if (options.all) return callback(null, resolved);
+		return callback(null, resolved[0].address, resolved[0].family);
+	});
+};
+const publicHttpsAgent = new node_https.Agent({ lookup: guardedLookup });
+const toIpv6Groups = (address) => {
+	let text = address.toLowerCase();
+	const dotted = text.match(/(\d+)\.(\d+)\.(\d+)\.(\d+)$/);
+	const ipv4Groups = [];
+	if (dotted) {
+		const [a, b, c, d] = dotted.slice(1).map((part) => _prismatic_io_spectral.util.types.toInt(part));
+		ipv4Groups.push(a << 8 | b, c << 8 | d);
+		text = `${text.slice(0, dotted.index)}0:0`;
+	}
+	const [head, tail] = text.includes("::") ? text.split("::") : [text, void 0];
+	const headGroups = head ? head.split(":") : [];
+	const tailGroups = tail ? tail.split(":") : [];
+	const fill = tail === void 0 ? [] : Array(8 - headGroups.length - tailGroups.length).fill("0");
+	const groups = [
+		...headGroups,
+		...fill,
+		...tailGroups
+	].map((group) => _prismatic_io_spectral.util.types.toNumber(`0x${group}`));
+	return ipv4Groups.length ? [...groups.slice(0, 6), ...ipv4Groups] : groups;
+};
+const embeddedIpv4 = (groups) => {
+	const toIpv4 = (high, low) => [
+		high >> 8,
+		high & 255,
+		low >> 8,
+		low & 255
+	].join(".");
+	const zeros = (from, to) => groups.slice(from, to).every((group) => group === 0);
+	if (groups[0] === 8194) return toIpv4(groups[1], groups[2]);
+	if (groups[0] === 100 && groups[1] === 65435 && zeros(2, 6)) return toIpv4(groups[6], groups[7]);
+	if (zeros(0, 5) && (groups[5] === 0 || groups[5] === 65535)) return toIpv4(groups[6], groups[7]);
+};
+function isBlockedAddress(address) {
+	const family = (0, node_net.isIP)(address);
+	if (family === 4) return blockedRanges.check(address, "ipv4");
+	if (family !== 6) return false;
+	if (blockedRanges.check(address, "ipv6")) return true;
+	const ipv4 = embeddedIpv4(toIpv6Groups(address));
+	return ipv4 !== void 0 && blockedRanges.check(ipv4, "ipv4");
+}
+//#endregion
+//#region src/client.ts
+const SETUP_HINT = "AEM returned 403 Forbidden. Confirm the connection's Client ID is listed under allowedClientIDs.author in the environment's config/api.yaml, and that the Developer Console credential includes a product profile with access to this API.";
+const WEB_APP_SETUP_HINT = "AEM returned 403 Forbidden. Confirm the connection's Client ID is listed under allowedClientIDs.author in the environment's config/api.yaml, and that the signed-in Adobe user has AEM access to this content.";
+const GATEWAY_INVALID_API_KEY = "403003";
+const GATEWAY_HINT = "Adobe's API gateway rejected the connection's Client ID for this endpoint (Api Key is invalid). Confirm the Developer Console project behind the credential includes the AEM API that serves this request.";
+const retryConfig = {
+	retries: 5,
+	useExponentialBackoff: true,
+	retryCondition: (error) => RETRYABLE_STATUS_CODES.includes(error.response?.status ?? 0)
+};
+const getAemHost = (connection) => {
+	const raw = _prismatic_io_spectral.util.types.toString(connection.fields.aemHost).trim();
+	let parsed;
+	try {
+		parsed = new URL(/^https?:\/\//i.test(raw) ? raw : `https://${raw}`);
+	} catch {
+		parsed = void 0;
+	}
+	const host = (parsed?.hostname ?? raw).toLowerCase().replace(/\.$/, "");
+	if (!parsed || parsed.username || parsed.password || parsed.port || !/^[a-z0-9-]+(\.[a-z0-9-]+)*$/.test(host) || !host.endsWith(".adobeaemcloud.com")) throw new _prismatic_io_spectral.ConnectionError(connection, `AEM Author Host must be an AEM as a Cloud Service host ending in ${AEM_HOST_SUFFIX}, such as author-p12345-e123456${AEM_HOST_SUFFIX}. Received: "${host}"`);
+	return host;
+};
+const getAuthHeaders = (connection) => {
+	if (connection.key !== aemOAuthServerToServer.key && connection.key !== aemOAuthWebApp.key) throw new _prismatic_io_spectral.ConnectionError(connection, `Unexpected connection type: ${connection.key}`);
+	return {
+		Authorization: `Bearer ${_prismatic_io_spectral.util.types.toString(connection.token?.access_token)}`,
+		"X-Api-Key": _prismatic_io_spectral.util.types.toString(connection.fields.clientId)
+	};
+};
+const MISSING_SCOPES_DETAIL = /missing required scopes/i;
+const WEB_APP_SCOPES_HINT = "This request needs a scope the OAuth Web App credential is not granted, so use the OAuth 2.0 Client Credentials connection for it: content fragment actions and the New and Updated Fragments trigger need it.";
+const HTML_PAGE_HINT = "Adobe returned an HTML error page instead of a JSON problem, which it does for a job or asset ID it does not know.";
+const UNAVAILABLE_STATUS_CODES = [
+	502,
+	503,
+	504
+];
+const UNAVAILABLE_HINT = "The Adobe Experience Manager environment is unavailable. A sandbox environment answers this way for several minutes while it de-hibernates or restarts: check its status in Cloud Manager and retry.";
+const HTML_SUCCESS_MESSAGE = "Adobe Experience Manager returned an HTML page instead of a JSON response. A hibernated sandbox environment answers this way: de-hibernate it in Cloud Manager and retry.";
+const HTML_PAGE_PATTERN = /^\s*(<!doctype html|<html)/i;
+const addSetupHint = (client, connection) => {
+	const hint = connection.key === aemOAuthWebApp.key ? WEB_APP_SETUP_HINT : SETUP_HINT;
+	client.interceptors.response.use(void 0, (error) => {
+		if (typeof error.response?.data === "string" && HTML_PAGE_PATTERN.test(error.response.data)) {
+			error.response.data = "(HTML error page omitted)";
+			const unavailable = UNAVAILABLE_STATUS_CODES.includes(error.response.status ?? 0);
+			error.message = `${error.message}. ${unavailable ? UNAVAILABLE_HINT : HTML_PAGE_HINT}`;
+		}
+		if (error.response?.status === 403) {
+			const body = error.response.data;
+			const detail = typeof body?.detail === "string" ? body.detail : void 0;
+			error.message = `${body?.error_code === GATEWAY_INVALID_API_KEY ? GATEWAY_HINT : connection.key === aemOAuthWebApp.key && detail && MISSING_SCOPES_DETAIL.test(detail) ? WEB_APP_SCOPES_HINT : hint}${detail ? ` Adobe: ${detail}` : ""} ${error.message}`;
+		}
+		return Promise.reject(error);
+	});
+};
+const getAemBaseUrl = (connection) => `https://${getAemHost(connection)}`;
+const createAemClient = (connection, debug = false) => {
+	const client = (0, _prismatic_io_spectral_http.createClient)({
+		baseUrl: getAemBaseUrl(connection),
+		headers: getAuthHeaders(connection),
+		debug,
+		retryConfig,
+		responseType: "json"
+	});
+	client.interceptors.response.use((response) => {
+		if (typeof response.data === "string" && HTML_PAGE_PATTERN.test(response.data)) throw new Error(HTML_SUCCESS_MESSAGE);
+		return response;
+	});
+	addSetupHint(client, connection);
+	return client;
+};
+const createAemDownloadClient = (connection, debug = false) => {
+	const client = (0, _prismatic_io_spectral_http.createClient)({
+		baseUrl: getAemBaseUrl(connection),
+		headers: getAuthHeaders(connection),
+		debug,
+		retryConfig,
+		responseType: "arraybuffer"
+	});
+	addSetupHint(client, connection);
+	return client;
+};
+const isIoEventsConnection = (connection) => connection.key === aemOAuthServerToServer.key;
+const createIoEventsClient = (connection, debug = false) => {
+	if (!isIoEventsConnection(connection)) throw new _prismatic_io_spectral.ConnectionError(connection, "Adobe I/O Events registrations require the OAuth 2.0 Client Credentials connection.");
+	return (0, _prismatic_io_spectral_http.createClient)({
+		baseUrl: IO_EVENTS_BASE_URL,
+		headers: getAuthHeaders(connection),
+		debug,
+		retryConfig,
+		responseType: "json"
+	});
+};
+const createPublicClient = (debug = false) => {
+	const client = (0, _prismatic_io_spectral_http.createClient)({
+		baseUrl: "",
+		debug,
+		retryConfig,
+		responseType: "text"
+	});
+	client.defaults.httpsAgent = publicHttpsAgent;
+	client.defaults.beforeRedirect = (options) => {
+		assertPublicUrl(_prismatic_io_spectral.util.types.toString(options.href));
+	};
+	client.interceptors.request.use((config) => {
+		assertPublicUrl(_prismatic_io_spectral.util.types.toString(config.url));
+		return config;
+	});
+	return client;
+};
+//#endregion
+//#region src/examplePayloads/assets.ts
+const exampleAssetSearchHit$1 = {
+	assetId: "urn:aaid:aem:4f2b6c1e-8d3a-4b5c-9e7f-0a1b2c3d4e5f",
+	repositoryMetadata: {
+		"repo:name": "city.jpeg",
+		"repo:path": "/content/dam/wknd-shared/en/city.jpeg",
+		"repo:assetId": "urn:aaid:aem:4f2b6c1e-8d3a-4b5c-9e7f-0a1b2c3d4e5f",
+		"repo:createDate": "2026-04-14T06:31:07.174Z",
+		"repo:modifyDate": "2026-04-15T05:01:44.229Z",
+		"repo:ancestors": ["urn:aaid:aem:abcd1234-ab12-ab12-ab12-abcdef123456"],
+		"dc:format": "image/jpeg",
+		"repo:size": 338049,
+		"aem:published": "2026-04-15T05:03:47.229Z"
+	},
+	assetMetadata: {
+		"dc:title": "City Skyline",
+		"xcm:keywords": [{
+			tagId: "f47ac10b-58cc-4372-a567-0e02b2c3d479",
+			value: "WKND Shared : Region / City",
+			"repo:ancestors": [
+				"wknd-shared",
+				"region",
+				"city"
+			]
+		}]
+	}
+};
+const searchAssetsExamplePayload = { data: {
+	hits: { results: [exampleAssetSearchHit$1] },
+	cursor: "eyJzZWFyY2hBZnRlciI6WzE3MTMxNTc3MDQyMjldfQ",
+	search_metadata: {
+		count: 1,
+		totalCount: {
+			total: 1,
+			relation: "eq"
+		},
+		searchDuration: 42
+	}
+} };
+const getAssetMetadataExamplePayload = { data: {
+	assetId: exampleAssetSearchHit$1.assetId,
+	repositoryMetadata: exampleAssetSearchHit$1.repositoryMetadata,
+	assetMetadata: exampleAssetSearchHit$1.assetMetadata
+} };
+const listAssetRenditionsExamplePayload = { data: {
+	assetId: "urn:aaid:aem:4f2b6c1e-8d3a-4b5c-9e7f-0a1b2c3d4e5f",
+	"repo:name": "city.jpeg",
+	items: [{
+		name: "cq5dam.web.1280.1280.jpeg",
+		format: "image/jpeg",
+		size: 102400,
+		dimensions: {
+			width: 1280,
+			height: 998
+		}
+	}, {
+		name: "cq5dam.thumbnail.319.319.png",
+		format: "image/png",
+		size: 40960,
+		dimensions: {
+			width: 319,
+			height: 249
+		}
+	}]
+} };
+const downloadAssetExamplePayload = {
+	data: Buffer.from("example binary content"),
+	contentType: "image/jpeg"
+};
+const downloadAssetRenditionExamplePayload = {
+	data: Buffer.from("example binary content"),
+	contentType: "image/jpeg"
+};
+const importAssetFromUrlExamplePayload = { data: {
+	id: "6a7b8c9d-0e1f-4a2b-8c3d-4e5f6a7b8c9d",
+	operation: "aem.assets.import.fromurl",
+	state: "PROCESSING",
+	data: {
+		id: "6a7b8c9d-0e1f-4a2b-8c3d-4e5f6a7b8c9d",
+		config: {
+			folder: "/content/dam/wknd-shared/en",
+			items: ["https://www.example.com/images/city.jpeg"]
+		},
+		progress: {
+			step: "QUEUED",
+			total: 1,
+			imported: 0,
+			failed: 0,
+			skipped: 0,
+			size: 338049,
+			transferred: 0,
+			started: "2026-04-15T05:00:12.418Z",
+			lastUpdated: "2026-04-15T05:00:12.418Z"
+		}
+	}
+} };
+const getImportJobStatusExamplePayload = { data: {
+	id: "6a7b8c9d-0e1f-4a2b-8c3d-4e5f6a7b8c9d",
+	operation: "aem.assets.import.fromurl",
+	status: 202,
+	description: "OK",
+	state: "PROCESSING",
+	progress: {
+		step: "IMPORTING",
+		total: 1,
+		imported: 0,
+		failed: 0,
+		skipped: 0,
+		size: 338049,
+		transferred: 169024,
+		started: "2026-04-15T05:00:12.418Z",
+		lastUpdated: "2026-04-15T05:00:14.902Z"
+	},
+	errors: []
+} };
+const updateAssetMetadataExamplePayload = getAssetMetadataExamplePayload;
+const getAssetJobStatusExamplePayload = { data: {
+	jobId: "7b8c9d0e-1f2a-4b3c-9d4e-5f6a7b8c9d0e",
+	state: "PROCESSING"
+} };
+const deleteAssetExamplePayload = { data: {
+	assetId: "urn:aaid:aem:4f2e8b1a-6c3d-4e5f-9a7b-8c9d0e1f2a3b",
+	deleted: true
+} };
+const selectAssetExamplePayload = { result: [{
+	key: "urn:aaid:aem:4f2b6c1e-8d3a-4b5c-9e7f-0a1b2c3d4e5f",
+	label: "/content/dam/wknd-shared/en/city.jpeg"
+}] };
+const selectAssetRenditionExamplePayload = { result: [{
+	key: "cq5dam.thumbnail.319.319.png",
+	label: "cq5dam.thumbnail.319.319.png"
+}, {
+	key: "cq5dam.web.1280.1280.jpeg",
+	label: "cq5dam.web.1280.1280.jpeg"
+}] };
+//#endregion
+//#region src/examplePayloads/contentFragments.ts
+const exampleContentFragment$1 = {
+	id: "4f2b6c1e-8d3a-4b5c-9e7f-0a1b2c3d4e5f",
+	path: "/content/dam/wknd-shared/en/adventures/surf-camp-in-costa-rica/surf-camp-in-costa-rica",
+	title: "Surf Camp in Costa Rica",
+	description: "A week of surfing on the Pacific coast.",
+	status: "PUBLISHED",
+	created: {
+		at: "2026-03-02T15:04:11.000Z",
+		by: "admin",
+		fullName: "Admin User"
+	},
+	modified: {
+		at: "2026-09-18T09:21:44.000Z",
+		by: "jdoe",
+		fullName: "Jane Doe"
+	},
+	published: {
+		at: "2026-09-18T09:25:02.000Z",
+		by: "jdoe",
+		fullName: "Jane Doe"
+	},
+	model: {
+		id: "L2NvbmYvd2tuZC1zaGFyZWQvc2V0dGluZ3MvZGFtL2NmbS9tb2RlbHMvYWR2ZW50dXJl",
+		path: "/conf/wknd-shared/settings/dam/cfm/models/adventure",
+		name: "adventure",
+		title: "Adventure"
+	},
+	tags: [{
+		id: "wknd-shared:activity/surfing",
+		title: "Surfing",
+		titlePath: "WKND Shared : Activity / Surfing"
+	}],
+	fields: [{
+		name: "title",
+		type: "text",
+		multiple: false,
+		values: ["Surf Camp in Costa Rica"]
+	}, {
+		name: "description",
+		type: "long-text",
+		multiple: false,
+		mimeType: "text/html",
+		values: ["<p>A week of surfing on the Pacific coast.</p>"]
+	}]
+};
+const listContentFragmentsExamplePayload = { data: {
+	items: [exampleContentFragment$1],
+	cursor: "eyJsYXN0SWQiOiI0ZjJiNmMxZSJ9"
+} };
+const searchContentFragmentsExamplePayload = { data: {
+	items: [exampleContentFragment$1],
+	cursor: "eyJsYXN0SWQiOiI0ZjJiNmMxZSJ9"
+} };
+const getContentFragmentExamplePayload = { data: exampleContentFragment$1 };
+const listContentFragmentVariationsExamplePayload = { data: { items: [{
+	name: "summer",
+	title: "Summer",
+	description: "Seasonal variation for the summer campaign.",
+	fields: [{
+		name: "title",
+		type: "text",
+		multiple: false,
+		values: ["Summer Surf Camp"]
+	}],
+	tags: [],
+	modified: {
+		at: "2026-09-10T12:00:00.000Z",
+		by: "jdoe"
+	}
+}] } };
+const listContentFragmentModelsExamplePayload = { data: { items: [{
+	id: "L2NvbmYvd2tuZC1zaGFyZWQvc2V0dGluZ3MvZGFtL2NmbS9tb2RlbHMvYWR2ZW50dXJl",
+	path: "/conf/wknd-shared/settings/dam/cfm/models/adventure",
+	name: "Adventure",
+	description: "An adventure offered by WKND."
+}] } };
+const selectContentFragmentModelExamplePayload = { result: [{
+	key: "L2NvbmYvd2tuZC1zaGFyZWQvc2V0dGluZ3MvZGFtL2NmbS9tb2RlbHMvYWR2ZW50dXJl",
+	label: "Adventure"
+}] };
+const selectContentFragmentExamplePayload = { result: [{
+	key: exampleContentFragment$1.id,
+	label: `${exampleContentFragment$1.title} (${exampleContentFragment$1.path})`
+}] };
+//#endregion
+//#region src/examplePayloads/folders.ts
+const listFolderContentsExamplePayload = { data: {
+	self: {
+		type: "FOLDER",
+		folderId: "urn:aaid:aem:abcd1234-ab12-ab12-ab12-abcdef123456",
+		name: "en",
+		title: "English",
+		path: "/content/dam/wknd-shared/en"
+	},
+	children: [{
+		type: "FOLDER",
+		folderId: "urn:aaid:aem:bcde2345-bc23-bc23-bc23-bcdef2345678",
+		name: "adventures",
+		title: "Adventures",
+		path: "/content/dam/wknd-shared/en/adventures"
+	}, {
+		type: "ASSET",
+		assetId: "urn:aaid:aem:4f2b6c1e-8d3a-4b5c-9e7f-0a1b2c3d4e5f",
+		name: "city.jpeg",
+		size: 338049,
+		lastModifiedAt: "2026-04-15T05:01:44.229Z"
+	}],
+	cursor: "eyJvZmZzZXQiOjUwfQ"
+} };
+const listAssetsInFolderTreeExamplePayload = { data: [{
+	type: "ASSET",
+	assetId: "urn:aaid:aem:4f2b6c1e-8d3a-4b5c-9e7f-0a1b2c3d4e5f",
+	name: "city.jpeg",
+	size: 338049,
+	lastModifiedAt: "2026-04-15T05:01:44.229Z",
+	folderPath: "/content/dam/wknd-shared/en"
+}] };
+const folderJobExamplePayload = { data: {
+	jobId: "5f8b2c1e-3a4d-4e6f-9b7a-1c2d3e4f5a6b",
+	state: "PROCESSING"
+} };
+const deleteFoldersExamplePayload = folderJobExamplePayload;
+const getFolderJobStatusExamplePayload = folderJobExamplePayload;
+const createFoldersExamplePayload = { data: {
+	operation: "adobe.folders.createFolders",
+	status: 200,
+	description: "Created folders",
+	data: { values: { successes: [{
+		type: "FOLDER",
+		name: "adventures",
+		folderId: "urn:aaid:aem:72583e15-33e8-4c86-bc8c-1f0557d7aa7b",
+		path: "/content/dam/wknd-shared/en/adventures"
+	}] } },
+	errors: [],
+	warnings: []
+} };
+const selectFolderExamplePayload = { result: [{
+	key: "urn:aaid:aem:abcd1234-ab12-ab12-ab12-abcdef123456",
+	label: "/content/dam/wknd-shared/en"
+}] };
+const selectFolderPathExamplePayload = { result: [{
+	key: "/content/dam",
+	label: "/content/dam"
+}, {
+	key: "/content/dam/wknd-shared/en",
+	label: "/content/dam/wknd-shared/en"
+}] };
+//#endregion
+//#region src/examplePayloads/misc.ts
+const rawRequestExamplePayload = { data: { items: [] } };
+//#endregion
+//#region src/examplePayloads/pages.ts
+const listSitemapUrlsExamplePayload = { data: [{
+	loc: "https://www.example.com/en/adventures/surf-camp.html",
+	lastmod: "2026-09-18T09:25:02.000Z"
+}, {
+	loc: "https://www.example.com/en/about-us.html",
+	lastmod: null
+}] };
+const getPublishedPageHtmlExamplePayload = { data: {
+	url: "https://www.example.com/en/adventures/surf-camp.html",
+	finalUrl: "https://www.example.com/en/adventures/surf-camp.html",
+	statusCode: 200,
+	contentType: "text/html;charset=utf-8",
+	lastModified: "Thu, 18 Sep 2026 09:25:02 GMT",
+	etag: "\"a1b2c3d4\"",
+	html: "<!DOCTYPE html><html><head><title>Surf Camp</title></head><body><h1>Surf Camp</h1></body></html>"
+} };
+const selectSitemapPageExamplePayload = { result: [{
+	key: "https://www.example.com/en/about-us.html",
+	label: "https://www.example.com/en/about-us.html"
+}, {
+	key: "https://www.example.com/en/adventures/surf-camp.html",
+	label: "https://www.example.com/en/adventures/surf-camp.html"
+}] };
+//#endregion
+//#region src/examplePayloads/triggers.ts
+const exampleAssetSearchHit = searchAssetsExamplePayload.data.hits.results[0];
+const exampleContentFragment = getContentFragmentExamplePayload.data;
+const exampleTriggerPayloadBase = {
+	queryParameters: {},
+	rawBody: { data: null },
+	pathFragment: "",
+	webhookUrls: {},
+	webhookApiKeys: {},
+	invokeUrl: "",
+	executionId: "RXhhbXBsZUV4ZWN1dGlvblJlc3VsdElk",
+	customer: {
+		id: "testCustomerId",
+		name: "Test Customer",
+		externalId: "testExternalId"
+	},
+	instance: {
+		id: "testInstanceId",
+		name: "Test Instance"
+	},
+	user: {
+		id: "testUserId",
+		email: "user@example.com",
+		name: "Test User",
+		externalId: "testUserExternalId"
+	},
+	integration: {
+		id: "testIntegrationId",
+		name: "Test Integration",
+		versionSequenceId: "1",
+		externalVersion: ""
+	},
+	flow: {
+		id: "testFlowId",
+		name: "Test Flow",
+		stableId: "testFlowStableId"
+	},
+	startedAt: "2024-01-15T00:00:00.000Z",
+	globalDebug: false
+};
+const contentFragmentItem = {
+	changeType: "published",
+	record: {
+		resourceType: "contentFragment",
+		id: exampleContentFragment.id,
+		path: exampleContentFragment.path,
+		url: `https://www.example.com${exampleContentFragment.path}`,
+		title: exampleContentFragment.title,
+		tags: [{
+			id: "wknd-shared:activity/surfing",
+			title: "Surfing",
+			titlePath: "WKND Shared : Activity / Surfing"
+		}],
+		created: "2026-03-02T15:04:11.000Z",
+		modified: "2026-09-18T09:21:44.000Z",
+		published: "2026-09-18T09:25:02.000Z",
+		scope: "/content/dam/wknd-shared/en",
+		data: exampleContentFragment
+	}
+};
+const contentFragmentChangesExamplePayload = {
+	payload: {
+		...exampleTriggerPayloadBase,
+		headers: {},
+		body: { data: { items: [contentFragmentItem] } }
+	},
+	polledNoChanges: false
+};
+const assetItem = {
+	changeType: "published",
+	record: {
+		resourceType: "asset",
+		id: exampleAssetSearchHit.assetId,
+		path: "/content/dam/wknd-shared/en/city.jpeg",
+		url: "https://www.example.com/content/dam/wknd-shared/en/city.jpeg",
+		title: "City Skyline",
+		tags: [{
+			id: "f47ac10b-58cc-4372-a567-0e02b2c3d479",
+			title: "City",
+			titlePath: "WKND Shared : Region / City"
+		}],
+		created: "2026-04-14T06:31:07.174Z",
+		modified: "2026-04-15T05:01:44.229Z",
+		published: "2026-04-15T05:03:47.229Z",
+		scope: "urn:aaid:aem:abcd1234-ab12-ab12-ab12-abcdef123456",
+		data: exampleAssetSearchHit
+	}
+};
+const assetChangesExamplePayload = {
+	payload: {
+		...exampleTriggerPayloadBase,
+		headers: {},
+		body: { data: { items: [assetItem] } }
+	},
+	polledNoChanges: false
+};
+const exampleEvent = {
+	specversion: "1.0",
+	id: "1b4f6d3e-2a5c-4e8f-9b7a-0c1d2e3f4a5b",
+	source: "acct:aem-p12345-e123456@adobe.com",
+	type: "aem.sites.page.modified",
+	datacontenttype: "application/json",
+	time: "2026-09-18T09:25:02.374Z",
+	recipientclientid: "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6",
+	data: {
+		user: {
+			imsUserId: "ims-0123456789ABCDEF01234567@techacct.adobe.com",
+			principalId: "5f0e1d2c-3b4a-5968-7a8b-9c0d1e2f3a4b@techacct.adobe.com",
+			displayName: "5f0e1d2c-3b4a-5968-7a8b-9c0d1e2f3a4b@techacct.adobe.com"
+		},
+		path: "/content/wknd/us/en/adventures/surf-camp",
+		template: { id: "/conf/wknd/settings/wcm/templates/page-content" },
+		properties: [{
+			name: "cq:lastModified",
+			changeType: "modified"
+		}, {
+			name: "jcr:title",
+			changeType: "modified"
+		}]
+	}
+};
+const eventItem = {
+	changeType: "modified",
+	record: {
+		resourceType: "page",
+		id: "/content/wknd/us/en/adventures/surf-camp",
+		path: "/content/wknd/us/en/adventures/surf-camp",
+		url: "https://www.example.com/content/wknd/us/en/adventures/surf-camp.html",
+		title: null,
+		tags: [],
+		created: null,
+		modified: "2026-09-18T09:25:02.374Z",
+		published: null,
+		scope: "4566206088344853970",
+		data: exampleEvent
+	},
+	eventId: exampleEvent.id,
+	eventSource: exampleEvent.source,
+	eventType: exampleEvent.type
+};
+const aemSitesEventWebhookExamplePayload = {
+	payload: {
+		...exampleTriggerPayloadBase,
+		headers: { "content-type": "application/cloudevents+json" },
+		body: { data: eventItem }
+	},
+	branch: "Notification"
+};
+const exampleAssetEvent = {
+	specversion: "1.0",
+	id: "7c2e9a41-5d3b-4f6a-8e1c-2b9d0f4a6c83",
+	source: "acct:aem-p12345-e123456@adobe.com",
+	type: "aem.assets.asset.metadata_updated",
+	datacontenttype: "application/json",
+	time: "2026-09-18T09:31:47.364Z",
+	recipientclientid: "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6",
+	data: {
+		user: {
+			imsUserId: "ims-0123456789ABCDEF01234567@techacct.adobe.com",
+			principalId: "5f0e1d2c-3b4a-5968-7a8b-9c0d1e2f3a4b@techacct.adobe.com"
+		},
+		repositoryMetadata: {
+			"repo:repositoryId": "author-p12345-e123456.adobeaemcloud.com",
+			"repo:assetId": "urn:aaid:aem:5b8f3e2a-9c1d-4e7f-a6b2-3d4c5e6f7a8b",
+			"repo:name": "surf-camp-hero.jpg",
+			"repo:path": "/content/dam/wknd/en/adventures/surf-camp/surf-camp-hero.jpg",
+			"repo:ancestors": ["urn:aaid:aem:1a2b3c4d-5e6f-4a7b-8c9d-0e1f2a3b4c5d"],
+			"repo:state": "ACTIVE",
+			"repo:createDate": "2026-09-01T14:02:11.985Z",
+			"repo:modifyDate": "2026-09-01T14:02:43.218Z",
+			"dc:format": "image/jpeg",
+			"aem:assetState": "processed"
+		},
+		assetMetadata: { "dc:title": "Surf Camp Hero" }
+	}
+};
+const assetEventItem = {
+	changeType: "modified",
+	record: {
+		resourceType: "asset",
+		id: "urn:aaid:aem:5b8f3e2a-9c1d-4e7f-a6b2-3d4c5e6f7a8b",
+		path: "/content/dam/wknd/en/adventures/surf-camp/surf-camp-hero.jpg",
+		url: "https://www.example.com/content/dam/wknd/en/adventures/surf-camp/surf-camp-hero.jpg",
+		title: "Surf Camp Hero",
+		tags: [],
+		created: null,
+		modified: "2026-09-18T09:31:47.364Z",
+		published: null,
+		scope: "4566206088344853970",
+		data: exampleAssetEvent
+	},
+	eventId: exampleAssetEvent.id,
+	eventSource: exampleAssetEvent.source,
+	eventType: exampleAssetEvent.type
+};
+const aemAssetsEventWebhookExamplePayload = {
+	payload: {
+		...exampleTriggerPayloadBase,
+		headers: { "content-type": "application/cloudevents+json" },
+		body: { data: assetEventItem }
+	},
+	branch: "Notification"
+};
+//#endregion
+//#region src/utils/dates.ts
+const toIsoDate = (value) => _prismatic_io_spectral.util.types.toDate(DATE_ONLY_PATTERN.test(value) ? `${value}T00:00:00Z` : value);
+//#endregion
+//#region src/utils/clean.ts
+const cleanString = (value) => {
+	const str = _prismatic_io_spectral.util.types.toString(value).trim();
+	return str ? str : void 0;
+};
+const cleanRequiredString = (value) => _prismatic_io_spectral.util.types.toString(value).trim();
+const DAM_ROOT_RELATIVE = DEFAULT_DAM_ROOT.replace(/^\/+/, "");
+const toDamPath = (value) => {
+	const relative = value.replace(/^\/+/, "").replace(/\/+$/, "");
+	return `/${relative === DAM_ROOT_RELATIVE || relative.startsWith(`${DAM_ROOT_RELATIVE}/`) ? relative : `${DAM_ROOT_RELATIVE}/${relative}`}`.replace(/\/+$/, "");
+};
+const cleanDamPath = (value) => {
+	const str = _prismatic_io_spectral.util.types.toString(value).trim();
+	return str ? toDamPath(str) : void 0;
+};
+const cleanRequiredDamPath = (value) => {
+	const str = _prismatic_io_spectral.util.types.toString(value).trim();
+	return str ? toDamPath(str) : "";
+};
+const cleanStringList = (value) => (Array.isArray(value) ? value : []).map((item) => _prismatic_io_spectral.util.types.toString(item).trim()).filter((item) => item.length > 0);
+const cleanLimit = (value) => {
+	const str = _prismatic_io_spectral.util.types.toString(value).trim() || void 0;
+	if (str === void 0) return void 0;
+	const limit = /^\d+$/.test(str) ? _prismatic_io_spectral.util.types.toInt(str) : void 0;
+	if (limit === void 0 || limit < 1 || limit > 50) throw new Error(`Limit must be a whole number from 1 to 50. Received: ${str}`);
+	return limit;
+};
+const cleanOptionalDateTime = (value) => {
+	const str = _prismatic_io_spectral.util.types.toString(value).trim() || void 0;
+	if (str === void 0) return void 0;
+	let parsed;
+	try {
+		parsed = toIsoDate(str);
+	} catch {
+		throw new Error(`"${str}" is not a valid ISO 8601 date-time.`);
+	}
+	return parsed.toISOString();
+};
+const cleanHttpsUrl = (value) => {
+	const str = _prismatic_io_spectral.util.types.toString(value).trim() || void 0;
+	let parsed;
+	try {
+		parsed = str ? new URL(str) : void 0;
+	} catch {
+		parsed = void 0;
+	}
+	if (parsed?.protocol !== "https:") throw new Error(`"${str ?? ""}" must be an absolute https:// URL.`);
+	return parsed.href;
+};
+const cleanOptionalHttpsUrl = (value) => _prismatic_io_spectral.util.types.toString(value).trim() ? cleanHttpsUrl(value).replace(/\/$/, "") : void 0;
+const lookBackDateClean = (value) => {
+	const raw = cleanString(value);
+	if (raw === void 0) return "";
+	const match = typeof value === "string" ? raw.match(DATE_ONLY_PATTERN) : null;
+	if (!match) throw new Error(`Look-back Date must be a date in YYYY-MM-DD format. Received: ${raw}`);
+	const [, yearStr, monthStr, dayStr] = match;
+	const year = _prismatic_io_spectral.util.types.toInt(yearStr);
+	const month = _prismatic_io_spectral.util.types.toInt(monthStr);
+	const day = _prismatic_io_spectral.util.types.toInt(dayStr);
+	const parsed = new Date(Date.UTC(year, month - 1, day));
+	if (parsed.getUTCFullYear() !== year || parsed.getUTCMonth() !== month - 1 || parsed.getUTCDate() !== day) throw new Error(`Look-back Date must be a date in YYYY-MM-DD format. Received: ${raw}`);
+	if (parsed.getTime() > Date.now()) throw new Error(`Look-back Date cannot be a future date. Received: ${raw}`);
+	return parsed.toISOString();
+};
+const cleanFolderPaths = (value) => {
+	const paths = (Array.isArray(value) ? value : []).map((item) => _prismatic_io_spectral.util.types.toString(item).trim()).filter((item) => item.length > 0).map(toDamPath);
+	if (!paths.length) throw new Error("Folder Paths must contain at least one folder path.");
+	return paths;
+};
+const cleanKeyValueRecord = (value) => {
+	const pairs = (Array.isArray(value) ? value : []).map((pair) => ({
+		key: _prismatic_io_spectral.util.types.toString(pair.key).trim(),
+		value: pair.value
+	})).filter((pair) => pair.key.length > 0);
+	return _prismatic_io_spectral.util.types.keyValPairListToObject(pairs, _prismatic_io_spectral.util.types.toString);
+};
+//#endregion
+//#region src/inputs/common.ts
+const connection = (0, _prismatic_io_spectral.input)({
+	label: "Connection",
+	type: "connection",
+	required: true,
+	comments: "The AEM as a Cloud Service connection to use."
+});
+const fetchAll = (0, _prismatic_io_spectral.input)({
+	label: "Fetch All",
+	type: "boolean",
+	required: false,
+	default: "false",
+	comments: `When true, automatically fetches all pages of results using pagination, up to 500 pages of 50. Limit is ignored; when Cursor is set, fetching starts from that page. When more results remain, the output includes a cursor to continue from.`,
+	clean: _prismatic_io_spectral.util.types.toBool
+});
+const cursor = (0, _prismatic_io_spectral.input)({
+	label: "Cursor",
+	placeholder: "Enter cursor",
+	type: "string",
+	required: false,
+	comments: "The cursor returned by a previous page, used to fetch the next page.",
+	example: "eyJsYXN0SWQiOiIxMjM0NSJ9",
+	clean: cleanString
+});
+const limit = (0, _prismatic_io_spectral.input)({
+	label: "Limit",
+	placeholder: "Enter limit",
+	type: "string",
+	required: false,
+	comments: `The maximum number of results to return per page, from 1 to 50.`,
+	example: "25",
+	clean: cleanLimit
+});
+const pagination = (0, _prismatic_io_spectral.structuredObjectInput)({
+	label: "Pagination",
+	required: false,
+	comments: "Cursor and page-size controls for paging through results.",
+	inputs: {
+		cursor,
+		limit
+	}
+});
+const sortOrder = (0, _prismatic_io_spectral.input)({
+	label: "Sort Order",
+	type: "string",
+	required: false,
+	default: "ASC",
+	model: SORT_ORDERS,
+	comments: "The direction to sort results in. Used only when Sort By is set.",
+	clean: cleanString
+});
+//#endregion
+//#region src/inputs/folders.ts
+const folderPath = (0, _prismatic_io_spectral.input)({
+	label: "Folder Path",
+	placeholder: "Enter folder path",
+	type: "string",
+	required: true,
+	default: DEFAULT_DAM_ROOT,
+	dataSource: "selectFolderPath",
+	comments: "The folder path below /content/dam, such as wknd-shared/en. A full repository path starting with /content/dam is also accepted.",
+	example: "wknd-shared/en",
+	clean: cleanRequiredDamPath
+});
+const listFolderContentsInputs = {
+	connection,
+	path: folderPath,
+	fetchAll,
+	pagination,
+	types: (0, _prismatic_io_spectral.input)({
+		label: "Item Types",
+		type: "string",
+		required: false,
+		default: "FOLDER,ASSET",
+		model: FOLDER_LISTING_TYPES,
+		comments: "Which kinds of items to list.",
+		clean: cleanString
+	}),
+	orderBy: (0, _prismatic_io_spectral.input)({
+		label: "Order By",
+		type: "string",
+		required: false,
+		model: FOLDER_ORDER_BY,
+		comments: "The field to order items by. Leave empty for the API default order.",
+		clean: cleanString
+	})
+};
+const listAssetsInFolderTreeInputs = {
+	connection,
+	path: {
+		...folderPath,
+		label: "Root Folder Path",
+		dataSource: "selectFolderPath",
+		comments: "The path of the folder to walk, below /content/dam, such as wknd-shared/en. Assets in every subfolder are included. A full repository path starting with /content/dam is also accepted."
+	}
+};
+const folderPaths = (0, _prismatic_io_spectral.input)({
+	label: "Folder Paths",
+	placeholder: "Enter folder path",
+	type: "string",
+	collection: "valuelist",
+	required: true,
+	comments: "The folder paths below /content/dam, such as wknd-shared/en/new-folder. A full repository path starting with /content/dam is also accepted.",
+	example: "wknd-shared/en/new-folder",
+	clean: cleanFolderPaths
+});
+const recursive = (0, _prismatic_io_spectral.input)({
+	label: "Recursive",
+	type: "boolean",
+	required: false,
+	default: "false",
+	comments: "When true, deletes each folder and everything inside it.",
+	clean: _prismatic_io_spectral.util.types.toBool
+});
+const force = (0, _prismatic_io_spectral.input)({
+	label: "Force",
+	type: "boolean",
+	required: false,
+	default: "false",
+	comments: "When true, deletes even when assets in the folders are referenced elsewhere.",
+	clean: _prismatic_io_spectral.util.types.toBool
+});
+const jobId = (0, _prismatic_io_spectral.input)({
+	label: "Job ID",
+	placeholder: "Enter job ID",
+	type: "string",
+	required: true,
+	comments: "The job ID returned by the action that started the job.",
+	example: "5f8b2c1e-3a4d-4e6f-9b7a-1c2d3e4f5a6b",
+	clean: cleanRequiredString
+});
+const createFoldersInputs = {
+	connection,
+	folderPaths
+};
+const deleteFoldersInputs = {
+	connection,
+	folderPaths: {
+		...folderPaths,
+		dataSource: "selectFolderPath"
+	},
+	recursive,
+	force
+};
+const getFolderJobStatusInputs = {
+	connection,
+	jobId
+};
+//#endregion
+//#region src/inputs/assets.ts
+const assetId = (0, _prismatic_io_spectral.input)({
+	label: "Asset ID",
+	placeholder: "Enter asset ID",
+	type: "string",
+	required: true,
+	dataSource: "selectAsset",
+	comments: "The ID of the asset, in urn:aaid:aem:... form.",
+	example: "urn:aaid:aem:4f2b6c1e-8d3a-4b5c-9e7f-0a1b2c3d4e5f",
+	clean: cleanRequiredString
+});
+const seoName = (0, _prismatic_io_spectral.input)({
+	label: "File Name",
+	placeholder: "Enter file name",
+	type: "string",
+	required: true,
+	comments: "The file name to request the binary under, usually the asset's own name.",
+	example: "city.jpeg",
+	clean: cleanRequiredString
+});
+const renditionName = (0, _prismatic_io_spectral.input)({
+	label: "Rendition Name",
+	placeholder: "Enter rendition name",
+	type: "string",
+	required: true,
+	dataSource: "selectAssetRendition",
+	comments: "The name of the rendition, as returned by List Asset Renditions.",
+	example: "cq5dam.web.1280.1280.jpeg",
+	clean: cleanRequiredString
+});
+const folderIds = (0, _prismatic_io_spectral.input)({
+	label: "Folders",
+	placeholder: "Select folder",
+	type: "string",
+	collection: "valuelist",
+	required: false,
+	default: [],
+	dataSource: "selectFolder",
+	comments: "Only include assets inside one of these folder IDs, at any depth.",
+	example: "urn:aaid:aem:abcd1234-ab12-ab12-ab12-abcdef123456",
+	clean: cleanStringList
+});
+const mimeTypes = (0, _prismatic_io_spectral.input)({
+	label: "MIME Types",
+	placeholder: "Enter MIME type",
+	type: "string",
+	collection: "valuelist",
+	required: false,
+	default: [],
+	comments: "Only include assets with one of these exact MIME types.",
+	example: "application/pdf",
+	clean: cleanStringList
+});
+const searchAssetsInputs = {
+	connection,
+	fetchAll,
+	pagination,
+	folderIds,
+	mimeTypes,
+	modifiedAfter: (0, _prismatic_io_spectral.input)({
+		label: "Modified After",
+		placeholder: "Enter date-time (ISO 8601)",
+		type: "string",
+		required: false,
+		comments: "Only return assets modified at or after this ISO 8601 date-time.",
+		example: "2026-01-01T00:00:00Z",
+		clean: cleanOptionalDateTime
+	}),
+	modifiedBefore: (0, _prismatic_io_spectral.input)({
+		label: "Modified Before",
+		placeholder: "Enter date-time (ISO 8601)",
+		type: "string",
+		required: false,
+		comments: "Only return assets modified before this ISO 8601 date-time.",
+		example: "2026-02-01T00:00:00Z",
+		clean: cleanOptionalDateTime
+	}),
+	filters: (0, _prismatic_io_spectral.structuredObjectInput)({
+		label: "Filters",
+		required: false,
+		comments: "Optional query controls to sort and refine the results.",
+		inputs: {
+			searchText: (0, _prismatic_io_spectral.input)({
+				label: "Search Text",
+				placeholder: "Enter search text",
+				type: "string",
+				required: false,
+				comments: "Full-text search across asset metadata. Leave empty to match every asset.",
+				example: "city skyline",
+				clean: cleanString
+			}),
+			sortField: (0, _prismatic_io_spectral.input)({
+				label: "Sort By",
+				type: "string",
+				required: false,
+				model: ASSET_SORT_FIELDS,
+				comments: "The field to sort results by. Leave empty to sort by relevance.",
+				clean: cleanString
+			}),
+			sortOrder
+		}
+	})
+};
+const getAssetMetadataInputs = {
+	connection,
+	assetId
+};
+const listAssetRenditionsInputs = {
+	connection,
+	assetId
+};
+const downloadAssetInputs = {
+	connection,
+	assetId,
+	seoName
+};
+const downloadAssetRenditionInputs = {
+	connection,
+	assetId,
+	renditionName,
+	seoName
+};
+const destinationFolder = (0, _prismatic_io_spectral.input)({
+	label: "Destination Folder Path",
+	placeholder: "Enter folder path",
+	type: "string",
+	required: true,
+	dataSource: "selectFolderPath",
+	comments: "The path of the folder to import into, below /content/dam, such as wknd-shared/en. A full repository path starting with /content/dam is also accepted.",
+	example: "wknd-shared/en",
+	clean: cleanRequiredDamPath
+});
+const fileUrl = (0, _prismatic_io_spectral.input)({
+	label: "File URL",
+	placeholder: "Enter file URL",
+	type: "string",
+	required: true,
+	comments: "The https:// URL AEM downloads the file from. It must be reachable from AEM.",
+	example: "https://cdn.example.com/city.jpeg",
+	clean: cleanHttpsUrl
+});
+const importMimeType = (0, _prismatic_io_spectral.input)({
+	label: "MIME Type",
+	placeholder: "Enter MIME type",
+	type: "string",
+	required: false,
+	comments: "The file's MIME type. Leave empty to let AEM detect it.",
+	example: "image/jpeg",
+	clean: cleanString
+});
+const metadataValues = (0, _prismatic_io_spectral.input)({
+	label: "Metadata Values",
+	placeholder: "Enter metadata field and value",
+	type: "string",
+	collection: "keyvaluelist",
+	required: false,
+	default: [],
+	comments: "Metadata fields to set, keyed by field name such as dc:title. Only asset metadata is writable; repository metadata is read-only.",
+	example: "dc:title",
+	clean: cleanKeyValueRecord
+});
+const removeFields = (0, _prismatic_io_spectral.input)({
+	label: "Fields to Remove",
+	placeholder: "Enter field name",
+	type: "string",
+	collection: "valuelist",
+	required: false,
+	default: [],
+	comments: "Metadata field names to remove from the asset, such as dc:description.",
+	example: "dc:description",
+	clean: cleanStringList
+});
+const forceDelete = (0, _prismatic_io_spectral.input)({
+	label: "Force",
+	type: "boolean",
+	required: false,
+	default: "false",
+	comments: "When true, deletes the asset even when it is referenced elsewhere.",
+	clean: _prismatic_io_spectral.util.types.toBool
+});
+const importAssetFromUrlInputs = {
+	connection,
+	folder: destinationFolder,
+	fileUrl,
+	fileName: {
+		...seoName,
+		comments: "The name the asset is created with."
+	},
+	mimeType: importMimeType
+};
+const getImportJobStatusInputs = {
+	connection,
+	jobId
+};
+const updateAssetMetadataInputs = {
+	connection,
+	assetId,
+	metadataValues,
+	removeFields
+};
+const deleteAssetInputs = {
+	connection,
+	assetId,
+	force: forceDelete
+};
+const getAssetJobStatusInputs = {
+	connection,
+	jobId
+};
+//#endregion
+//#region src/inputs/contentFragments.ts
+const fragmentId = (0, _prismatic_io_spectral.input)({
+	label: "Content Fragment ID",
+	placeholder: "Select content fragment",
+	type: "string",
+	required: true,
+	dataSource: "selectContentFragment",
+	comments: "The unique identifier for the content fragment, a UUID as returned by List Content Fragments or Search Content Fragments.",
+	example: "4f2b6c1e-8d3a-4b5c-9e7f-0a1b2c3d4e5f",
+	clean: cleanRequiredString
+});
+const tags = (0, _prismatic_io_spectral.input)({
+	label: "Tags",
+	placeholder: "Enter tag ID",
+	type: "string",
+	collection: "valuelist",
+	required: false,
+	default: [],
+	comments: "Only return content fragments with at least one of these tag IDs.",
+	example: "wknd-shared:season/summer",
+	clean: cleanStringList
+});
+const locales = (0, _prismatic_io_spectral.input)({
+	label: "Locales",
+	placeholder: "Enter locale",
+	type: "string",
+	collection: "valuelist",
+	required: false,
+	default: [],
+	comments: "Only return content fragments in one of these locales.",
+	example: "en",
+	clean: cleanStringList
+});
+const fragmentPath = (0, _prismatic_io_spectral.input)({
+	label: "Path",
+	placeholder: "Enter path",
+	type: "string",
+	required: false,
+	dataSource: "selectFolderPath",
+	comments: "Only return content fragments under this folder path below /content/dam, such as wknd/en/adventures. A full repository path starting with /content/dam is also accepted.",
+	example: "wknd/en/adventures",
+	clean: cleanDamPath
+});
+const onlyDirectChildren = (0, _prismatic_io_spectral.input)({
+	label: "Only Direct Children",
+	type: "boolean",
+	required: false,
+	default: "false",
+	comments: "When true, only returns content fragments directly under Path, not in its subfolders.",
+	clean: _prismatic_io_spectral.util.types.toBool
+});
+const projection = (0, _prismatic_io_spectral.input)({
+	label: "Projection",
+	type: "string",
+	required: false,
+	model: CONTENT_FRAGMENT_PROJECTIONS,
+	comments: "How much of each content fragment to return. Leave empty for the API default.",
+	clean: cleanString
+});
+const includeMetadata = (0, _prismatic_io_spectral.input)({
+	label: "Include Metadata",
+	type: "boolean",
+	required: false,
+	default: "false",
+	comments: "When true, includes each content fragment's metadata in the response.",
+	clean: _prismatic_io_spectral.util.types.toBool
+});
+const references = (0, _prismatic_io_spectral.input)({
+	label: "References",
+	type: "string",
+	required: false,
+	model: CONTENT_FRAGMENT_REFERENCES,
+	comments: "Which referenced content to include. Leave empty to omit references.",
+	clean: cleanString
+});
+const statuses = (0, _prismatic_io_spectral.input)({
+	label: "Statuses",
+	type: "string",
+	collection: "valuelist",
+	required: false,
+	default: [],
+	model: CONTENT_FRAGMENT_STATUSES,
+	comments: "Only return content fragments in one of these statuses.",
+	clean: cleanStringList
+});
+const modelIds = (0, _prismatic_io_spectral.input)({
+	label: "Content Fragment Models",
+	placeholder: "Select content fragment model",
+	type: "string",
+	collection: "valuelist",
+	required: false,
+	default: [],
+	dataSource: "selectContentFragmentModel",
+	comments: "Only return content fragments based on one of these model IDs.",
+	example: "L2NvbmYvd2tuZC1zaGFyZWQvc2V0dGluZ3MvZGFtL2NmbS9tb2RlbHMvYWR2ZW50dXJl",
+	clean: cleanStringList
+});
+const modifiedAfter$1 = (0, _prismatic_io_spectral.input)({
+	label: "Modified After",
+	placeholder: "Enter date-time (ISO 8601)",
+	type: "string",
+	required: false,
+	comments: "Only return content fragments modified after this ISO 8601 date-time.",
+	example: "2026-01-01T00:00:00Z",
+	clean: cleanOptionalDateTime
+});
+const modifiedBefore = (0, _prismatic_io_spectral.input)({
+	label: "Modified Before",
+	placeholder: "Enter date-time (ISO 8601)",
+	type: "string",
+	required: false,
+	comments: "Only return content fragments modified before this ISO 8601 date-time.",
+	example: "2026-02-01T00:00:00Z",
+	clean: cleanOptionalDateTime
+});
+const publishedAfter = (0, _prismatic_io_spectral.input)({
+	label: "Published After",
+	placeholder: "Enter date-time (ISO 8601)",
+	type: "string",
+	required: false,
+	comments: "Only return content fragments published after this ISO 8601 date-time.",
+	example: "2026-01-01T00:00:00Z",
+	clean: cleanOptionalDateTime
+});
+const publishedBefore = (0, _prismatic_io_spectral.input)({
+	label: "Published Before",
+	placeholder: "Enter date-time (ISO 8601)",
+	type: "string",
+	required: false,
+	comments: "Only return content fragments published before this ISO 8601 date-time.",
+	example: "2026-02-01T00:00:00Z",
+	clean: cleanOptionalDateTime
+});
+const fullText = (0, _prismatic_io_spectral.input)({
+	label: "Full Text",
+	placeholder: "Enter search text",
+	type: "string",
+	required: false,
+	comments: "Only return content fragments whose content matches this text.",
+	example: "summer camping",
+	clean: cleanString
+});
+const sortOn = (0, _prismatic_io_spectral.input)({
+	label: "Sort By",
+	type: "string",
+	required: false,
+	model: CONTENT_FRAGMENT_SORT_FIELDS,
+	comments: "The field to sort results by. Leave empty for the API default order.",
+	clean: cleanString
+});
+const dateRangeFilters = (0, _prismatic_io_spectral.structuredObjectInput)({
+	label: "Date Range Filters",
+	required: false,
+	comments: "Optional date-range filters. Narrow results by when content fragments were last modified or published.",
+	inputs: {
+		modifiedAfter: modifiedAfter$1,
+		modifiedBefore,
+		publishedAfter,
+		publishedBefore
+	}
+});
+const filters = (0, _prismatic_io_spectral.structuredObjectInput)({
+	label: "Filters",
+	required: false,
+	comments: "Optional query controls to sort and refine the results.",
+	inputs: {
+		fullText,
+		sortOn,
+		sortOrder
+	}
+});
+const listContentFragmentsInputs = {
+	connection,
+	fetchAll,
+	pagination,
+	path: fragmentPath,
+	projection,
+	includeMetadata,
+	references
+};
+const searchContentFragmentsInputs = {
+	connection,
+	fetchAll,
+	pagination,
+	path: fragmentPath,
+	onlyDirectChildren,
+	statuses,
+	modelIds,
+	tags,
+	locales,
+	dateRangeFilters,
+	filters,
+	projection,
+	includeMetadata
+};
+const getContentFragmentInputs = {
+	connection,
+	fragmentId,
+	includeMetadata,
+	references
+};
+const listContentFragmentVariationsInputs = {
+	connection,
+	fragmentId,
+	fetchAll,
+	pagination
+};
+const listContentFragmentModelsInputs = {
+	connection,
+	fetchAll,
+	pagination,
+	projection
+};
+//#endregion
+//#region src/inputs/pages.ts
+const sitemapUrl = (0, _prismatic_io_spectral.input)({
+	label: "Sitemap URL",
+	placeholder: "Enter sitemap URL",
+	type: "string",
+	required: true,
+	comments: "The https:// URL of the site's sitemap or sitemap index. Child sitemaps on the same host are followed.",
+	example: "https://www.example.com/sitemap.xml",
+	clean: cleanHttpsUrl
+});
+const modifiedAfter = (0, _prismatic_io_spectral.input)({
+	label: "Modified After",
+	placeholder: "Enter date-time (ISO 8601)",
+	type: "string",
+	required: false,
+	comments: "Only return pages whose sitemap lastmod is after this ISO 8601 date-time. Pages without a lastmod are excluded when set.",
+	example: "2026-01-01T00:00:00Z",
+	clean: cleanOptionalDateTime
+});
+const includePathPrefixes = (0, _prismatic_io_spectral.input)({
+	label: "Include Path Prefixes",
+	placeholder: "Enter path prefix",
+	type: "string",
+	collection: "valuelist",
+	required: false,
+	default: [],
+	comments: "Only return pages whose URL path starts with one of these prefixes.",
+	example: "/en/adventures",
+	clean: cleanStringList
+});
+const excludePathPrefixes = (0, _prismatic_io_spectral.input)({
+	label: "Exclude Path Prefixes",
+	placeholder: "Enter path prefix",
+	type: "string",
+	collection: "valuelist",
+	required: false,
+	default: [],
+	comments: "Leave out pages whose URL path starts with one of these prefixes.",
+	example: "/en/legal",
+	clean: cleanStringList
+});
+const pageUrl = (0, _prismatic_io_spectral.input)({
+	label: "Page URL",
+	placeholder: "Enter page URL",
+	type: "string",
+	required: true,
+	dataSource: "selectSitemapPage",
+	comments: "The https:// URL of the published page to fetch.",
+	example: "https://www.example.com/en/adventures/surf-camp.html",
+	clean: cleanHttpsUrl
+});
+const listSitemapUrlsInputs = {
+	connection,
+	sitemapUrl,
+	modifiedAfter,
+	includePathPrefixes,
+	excludePathPrefixes
+};
+const getPublishedPageHtmlInputs = {
+	connection,
+	sitemapUrl: (0, _prismatic_io_spectral.input)({
+		...sitemapUrl,
+		required: false,
+		clean: cleanOptionalHttpsUrl,
+		comments: "The https:// URL of the site's sitemap or sitemap index. Used only to populate the Page URL dropdown; this action does not send it."
+	}),
+	pageUrl
+};
+//#endregion
+//#region src/inputs/dataSources.ts
+const selectContentFragmentModelInputs = { connection };
+const selectFolderInputs = { connection };
+const selectContentFragmentInputs = {
+	connection,
+	path: {
+		...fragmentPath,
+		dataSource: void 0
+	}
+};
+const selectFolderPathInputs = { connection };
+const selectAssetInputs = { connection };
+const selectAssetRenditionInputs = {
+	connection,
+	assetId: {
+		...assetId,
+		dataSource: void 0
+	}
+};
+const selectSitemapPageInputs = {
+	connection,
+	sitemapUrl
+};
+//#endregion
+//#region src/inputs/misc.ts
+const { debugRequest: _debugRequest, ...httpInputs } = _prismatic_io_spectral_http.inputs;
+const rawRequestInputs = {
+	connection,
+	...httpInputs,
+	url: {
+		...httpInputs.url,
+		comments: "Input the path only (for example, /adobe/sites/cf/fragments). The AEM author host is already included.",
+		example: "/adobe/sites/cf/fragments"
+	}
+};
+//#endregion
+//#region src/inputs/triggers.ts
+const lookBackDate = (0, _prismatic_io_spectral.input)({
+	label: "Look-back Date",
+	placeholder: "Enter look-back date (YYYY-MM-DD)",
+	type: "string",
+	required: false,
+	comments: "The date the initial sync starts from, in YYYY-MM-DD format. Cannot be a future date. Leave empty to start from the first recurrence with no backfill. When set, the initial sync seeds each record modified on or after this date once.",
+	example: "2026-01-01",
+	clean: lookBackDateClean
+});
+const publishBaseUrl = (0, _prismatic_io_spectral.input)({
+	label: "Publish Base URL",
+	placeholder: "Enter publish base URL",
+	type: "string",
+	required: false,
+	comments: "The public base URL of the published site, used to build each record's URL from its path. Leave empty to omit URLs.",
+	example: "https://www.example.com",
+	clean: cleanOptionalHttpsUrl
+});
+const triggerStatuses = (0, _prismatic_io_spectral.input)({
+	label: "Statuses",
+	type: "string",
+	collection: "valuelist",
+	required: false,
+	default: DEFAULT_TRIGGER_FRAGMENT_STATUSES,
+	model: CONTENT_FRAGMENT_STATUSES,
+	comments: "Only emit content fragments in one of these statuses. The default covers live content: Published, and Modified (published, then edited).",
+	clean: cleanStringList
+});
+const consumerOrgId = (0, _prismatic_io_spectral.input)({
+	label: "Consumer Organization ID",
+	placeholder: "Enter consumer organization ID",
+	type: "string",
+	required: true,
+	comments: "The Adobe Developer Console consumer organization ID that owns the project.",
+	example: "123456",
+	clean: cleanRequiredString
+});
+const projectId = (0, _prismatic_io_spectral.input)({
+	label: "Project ID",
+	placeholder: "Enter project ID",
+	type: "string",
+	required: true,
+	comments: "The ID of the Adobe Developer Console project with AEM Events enabled.",
+	example: "4566206088344794931",
+	clean: cleanRequiredString
+});
+const workspaceId = (0, _prismatic_io_spectral.input)({
+	label: "Workspace ID",
+	placeholder: "Enter workspace ID",
+	type: "string",
+	required: true,
+	comments: "The ID of the Adobe Developer Console workspace within the project.",
+	example: "4566206088344853970",
+	clean: cleanRequiredString
+});
+const providerId = (0, _prismatic_io_spectral.input)({
+	label: "Event Provider ID",
+	placeholder: "Enter AEM Sites event provider ID",
+	type: "string",
+	required: true,
+	comments: "The ID of the environment's AEM Sites event provider. Adobe creates one AEM Sites provider and one AEM Assets provider per environment once AEM Events is enabled for it.",
+	example: "61378e83-878f-409c-ade1-0e3482aa90a7",
+	clean: cleanRequiredString
+});
+const sitesEventTypes = (0, _prismatic_io_spectral.input)({
+	label: "Event Types",
+	type: "string",
+	collection: "valuelist",
+	required: true,
+	default: AEM_SITES_EVENT_TYPES.map((eventType) => eventType.value),
+	model: AEM_SITES_EVENT_TYPES,
+	comments: "The AEM Sites content fragment and page events to subscribe to.",
+	clean: cleanStringList
+});
+const assetsEventTypes = (0, _prismatic_io_spectral.input)({
+	label: "Event Types",
+	type: "string",
+	collection: "valuelist",
+	required: true,
+	default: AEM_ASSETS_EVENT_TYPES.map((eventType) => eventType.value),
+	model: AEM_ASSETS_EVENT_TYPES,
+	comments: "The AEM Assets events to subscribe to.",
+	clean: cleanStringList
+});
+const contentFragmentChangesInputs = {
+	connection,
+	lookBackDate: {
+		...lookBackDate,
+		comments: "The date the initial sync starts from, in YYYY-MM-DD format. Cannot be a future date. Leave empty to start from the first recurrence with no backfill. When set, the initial sync seeds each content fragment modified on or after this date once."
+	},
+	path: fragmentPath,
+	statuses: triggerStatuses,
+	modelIds,
+	tags,
+	locales,
+	publishBaseUrl
+};
+const assetChangesInputs = {
+	connection,
+	lookBackDate: {
+		...lookBackDate,
+		comments: "The date the initial sync starts from, in YYYY-MM-DD format. Cannot be a future date. Leave empty to start from the first recurrence with no backfill. When set, the initial sync seeds each asset modified on or after this date once."
+	},
+	folderIds,
+	mimeTypes,
+	publishBaseUrl
+};
+const aemSitesEventWebhookInputs = {
+	connection,
+	consumerOrgId,
+	projectId,
+	workspaceId,
+	providerId,
+	eventTypes: sitesEventTypes,
+	publishBaseUrl
+};
+const aemAssetsEventWebhookInputs = {
+	connection,
+	consumerOrgId,
+	projectId,
+	workspaceId,
+	providerId: {
+		...providerId,
+		placeholder: "Enter AEM Assets event provider ID",
+		comments: "The ID of the environment's AEM Assets event provider. Adobe creates one AEM Sites provider and one AEM Assets provider per environment once AEM Events is enabled for it.",
+		example: "5b0beec8-725f-4881-97f4-bfb8bfb4b6d5"
+	},
+	eventTypes: assetsEventTypes,
+	publishBaseUrl
+};
+//#endregion
+//#region src/outputSchemas/shared.ts
+const auditStampSchema = {
+	type: "object",
+	properties: {
+		at: {
+			type: "string",
+			format: "date-time"
+		},
+		by: { type: "string" },
+		fullName: { type: "string" },
+		firstName: { type: "string" },
+		lastName: { type: "string" }
+	}
+};
+const replicationStatusSchema = {
+	type: "string",
+	enum: [
+		"PUBLISHED",
+		"UNPUBLISHED",
+		"MODIFIED",
+		"NEVER_PUBLISHED"
+	]
+};
+const previewStatusSchema = {
+	type: "string",
+	enum: ["IN_SYNC", "OUT_OF_SYNC"]
+};
+const contentFragmentStatusSchema = {
+	type: "string",
+	enum: [
+		"NEW",
+		"DRAFT",
+		"PUBLISHED",
+		"MODIFIED",
+		"UNPUBLISHED"
+	]
+};
+const dataTypeSchema = {
+	type: "string",
+	enum: [
+		"text",
+		"long-text",
+		"number",
+		"float-number",
+		"date-time",
+		"date",
+		"time",
+		"boolean",
+		"enumeration",
+		"tag",
+		"content-fragment",
+		"content-reference",
+		"json"
+	]
+};
+const tagSchema = {
+	type: "object",
+	properties: {
+		id: { type: "string" },
+		title: { type: "string" },
+		i18n: {
+			type: "array",
+			items: {
+				type: "object",
+				properties: {
+					locale: { type: "string" },
+					title: { type: "string" },
+					titlePath: { type: "string" }
+				}
+			}
+		},
+		titlePath: { type: "string" },
+		name: { type: "string" },
+		path: { type: "string" },
+		description: { type: "string" }
+	},
+	required: ["id"]
+};
+const validationStatusSchema = {
+	type: "array",
+	items: {
+		type: "object",
+		properties: {
+			property: { type: "string" },
+			message: { type: "string" }
+		}
+	}
+};
+const assetValueSchema = {
+	type: ["string", "object"],
+	properties: {
+		repository: { type: "string" },
+		assetId: { type: "string" }
+	}
+};
+const fragmentFieldSchema = {
+	type: "object",
+	properties: {
+		name: { type: "string" },
+		type: dataTypeSchema,
+		multiple: { type: "boolean" },
+		locked: { type: "boolean" },
+		mimeType: {
+			type: "string",
+			enum: [
+				"text/html",
+				"text/plain",
+				"text/x-markdown",
+				"text/markdown"
+			]
+		},
+		values: {
+			type: "array",
+			items: {
+				type: [
+					"string",
+					"number",
+					"boolean",
+					"object"
+				],
+				properties: {
+					repository: { type: "string" },
+					assetId: { type: "string" }
+				}
+			}
+		}
+	},
+	required: ["name", "type"]
+};
+const cardSchema = {
+	type: "object",
+	properties: {
+		assets: {
+			type: "array",
+			items: assetValueSchema
+		},
+		texts: {
+			type: "array",
+			items: { type: "string" }
+		}
+	}
+};
+const modelIdentifierSchema = {
+	type: "object",
+	properties: {
+		id: { type: "string" },
+		path: { type: "string" },
+		name: { type: "string" },
+		technicalName: { type: "string" },
+		title: { type: "string" },
+		description: { type: "string" },
+		tagIds: {
+			type: "array",
+			items: { type: "string" }
+		}
+	},
+	required: [
+		"id",
+		"path",
+		"name"
+	]
+};
+const referenceSchema = {
+	type: "object",
+	properties: {
+		name: { type: "string" },
+		fieldName: { type: "string" },
+		type: {
+			type: "string",
+			enum: [
+				"content-fragment",
+				"experience-fragment",
+				"asset",
+				"page"
+			]
+		},
+		title: { type: "string" },
+		description: { type: "string" },
+		path: { type: "string" },
+		created: auditStampSchema,
+		modified: auditStampSchema,
+		published: auditStampSchema,
+		status: contentFragmentStatusSchema,
+		previewReplicationStatus: replicationStatusSchema,
+		previewStatus: previewStatusSchema,
+		assetId: { type: "string" },
+		"repo:size": { type: "integer" },
+		"dc:format": { type: "string" },
+		"tiff:ImageWidth": { type: "integer" },
+		"tiff:ImageHeight": { type: "integer" },
+		id: {
+			type: "string",
+			format: "uuid"
+		},
+		references: {
+			type: "array",
+			items: { type: "object" }
+		},
+		model: modelIdentifierSchema,
+		fields: {
+			type: "array",
+			items: fragmentFieldSchema
+		},
+		variations: {
+			type: "array",
+			items: { type: "object" }
+		},
+		tags: {
+			type: "array",
+			items: tagSchema
+		}
+	},
+	required: ["type", "path"]
+};
+const contentFragmentVariationSchema = {
+	type: "object",
+	properties: {
+		name: { type: "string" },
+		title: { type: "string" },
+		description: { type: "string" },
+		fields: {
+			type: "array",
+			items: fragmentFieldSchema
+		},
+		tags: {
+			type: "array",
+			items: tagSchema
+		},
+		validationStatus: validationStatusSchema,
+		references: {
+			type: "array",
+			items: referenceSchema
+		},
+		fieldTags: {
+			type: "array",
+			items: tagSchema
+		},
+		created: auditStampSchema,
+		modified: auditStampSchema,
+		card: cardSchema
+	},
+	required: ["title"]
+};
+const contentFragmentSchema = {
+	type: "object",
+	properties: {
+		id: { type: "string" },
+		path: { type: "string" },
+		title: { type: "string" },
+		description: { type: "string" },
+		status: contentFragmentStatusSchema,
+		previewReplicationStatus: replicationStatusSchema,
+		previewStatus: previewStatusSchema,
+		created: auditStampSchema,
+		modified: auditStampSchema,
+		published: auditStampSchema,
+		model: modelIdentifierSchema,
+		checkedOutBy: { type: "string" },
+		validationStatus: validationStatusSchema,
+		fields: {
+			type: "array",
+			items: fragmentFieldSchema
+		},
+		variations: {
+			type: "array",
+			items: contentFragmentVariationSchema
+		},
+		tags: {
+			type: "array",
+			items: tagSchema
+		},
+		fieldTags: {
+			type: "array",
+			items: tagSchema
+		},
+		references: {
+			type: "array",
+			items: referenceSchema
+		},
+		card: cardSchema,
+		metadata: {
+			type: ["object", "null"],
+			properties: {
+				schemaId: { type: "string" },
+				fields: {
+					type: "array",
+					items: {
+						type: "object",
+						properties: {
+							name: { type: "string" },
+							type: {
+								type: "string",
+								enum: [
+									"string",
+									"integer",
+									"number",
+									"boolean",
+									"array",
+									"object"
+								]
+							},
+							value: { type: [
+								"string",
+								"number",
+								"boolean",
+								"array",
+								"object"
+							] },
+							title: { type: "string" }
+						},
+						required: ["name", "value"]
+					}
+				}
+			}
+		}
+	},
+	required: [
+		"id",
+		"path",
+		"title",
+		"status",
+		"created",
+		"model"
+	]
+};
+const minMaxSchema = {
+	type: "object",
+	properties: {
+		min: { type: "integer" },
+		max: { type: "integer" }
+	}
+};
+const fileSizeSchema = {
+	type: "object",
+	properties: {
+		size: { type: "integer" },
+		unit: {
+			type: "string",
+			enum: [
+				"B",
+				"KB",
+				"MB",
+				"GB",
+				"TB"
+			]
+		}
+	},
+	required: ["size", "unit"]
+};
+const contentFragmentModelSchema = {
+	type: "object",
+	properties: {
+		id: { type: "string" },
+		path: { type: "string" },
+		name: { type: "string" },
+		technicalName: { type: "string" },
+		description: { type: "string" },
+		etag: { type: "string" },
+		created: auditStampSchema,
+		modified: auditStampSchema,
+		published: auditStampSchema,
+		locked: { type: "boolean" },
+		status: {
+			type: "string",
+			enum: [
+				"enabled",
+				"disabled",
+				"draft"
+			]
+		},
+		replicationStatus: replicationStatusSchema,
+		previewReplicationStatus: replicationStatusSchema,
+		previewStatus: previewStatusSchema,
+		previewUrlPattern: { type: "string" },
+		tagsCount: { type: "integer" },
+		tags: {
+			type: "array",
+			items: tagSchema
+		},
+		fields: {
+			type: "array",
+			items: {
+				type: "object",
+				properties: {
+					name: { type: "string" },
+					label: { type: "string" },
+					description: { type: "string" },
+					required: { type: "boolean" },
+					multiple: { type: "boolean" },
+					minItems: { type: "integer" },
+					maxItems: { type: "integer" },
+					type: dataTypeSchema,
+					extensionConfig: {
+						type: "object",
+						additionalProperties: { type: [
+							"string",
+							"boolean",
+							"number",
+							"array"
+						] }
+					},
+					placeholder: { type: "string" },
+					defaultValue: { type: [
+						"string",
+						"number",
+						"boolean"
+					] },
+					maxLength: { type: "integer" },
+					unique: { type: "boolean" },
+					translatable: { type: "boolean" },
+					validationType: {
+						type: "string",
+						enum: [
+							"none",
+							"email",
+							"url",
+							"custom"
+						]
+					},
+					customValidationRegex: { type: "string" },
+					customErrorMessage: { type: "string" },
+					mimeType: {
+						type: "string",
+						enum: [
+							"text/html",
+							"text/plain",
+							"text/x-markdown",
+							"text/markdown"
+						]
+					},
+					allowFragmentReference: { type: "boolean" },
+					allowedModels: {
+						type: "array",
+						items: { type: "string" }
+					},
+					min: { type: "number" },
+					max: { type: "number" },
+					root: { type: "string" },
+					allowFragmentCreation: { type: "boolean" },
+					items: {
+						type: "array",
+						items: { type: "string" }
+					},
+					tags: {
+						type: "array",
+						items: { type: "string" }
+					},
+					uuidBased: { type: "boolean" },
+					showThumbnail: { type: "boolean" },
+					imageWidth: minMaxSchema,
+					imageHeight: minMaxSchema,
+					fileSizeMin: fileSizeSchema,
+					fileSizeMax: fileSizeSchema,
+					allowedContentTypes: {
+						type: "array",
+						items: {
+							type: "string",
+							enum: [
+								"plaintext",
+								"richtext",
+								"image",
+								"audio",
+								"video",
+								"pdf",
+								"spreadsheet",
+								"presentation",
+								"archive",
+								"markup",
+								"contentfragment"
+							]
+						}
+					},
+					hint: {
+						type: "string",
+						enum: [
+							"select",
+							"checkbox",
+							"radio"
+						]
+					},
+					values: {
+						type: "array",
+						items: {
+							type: "object",
+							properties: {
+								key: { type: "string" },
+								value: { type: "string" }
+							},
+							required: ["key", "value"]
+						}
+					}
+				},
+				required: [
+					"name",
+					"label",
+					"type"
+				]
+			}
+		}
+	},
+	required: [
+		"id",
+		"path",
+		"name"
+	]
+};
+const assetMetadataResourceSchema = {
+	type: "object",
+	properties: {
+		assetId: { type: "string" },
+		repositoryMetadata: {
+			type: "object",
+			properties: {
+				"repo:name": { type: "string" },
+				"repo:path": { type: "string" },
+				"repo:assetId": { type: "string" },
+				"repo:parent": { type: "string" },
+				"repo:ancestors": {
+					type: "array",
+					items: { type: "string" }
+				},
+				"repo:createDate": {
+					type: "string",
+					format: "date-time"
+				},
+				"repo:createdBy": { type: "string" },
+				"repo:modifyDate": {
+					type: "string",
+					format: "date-time"
+				},
+				"repo:modifiedBy": { type: "string" },
+				"dc:format": { type: "string" },
+				"repo:size": { type: "integer" },
+				"dam:sha1": { type: "string" },
+				"tiff:imageLength": { type: "integer" },
+				"tiff:imageWidth": { type: "integer" },
+				isPublishedToAemPublish: { type: "boolean" },
+				isPublishedToDynamicMedia: { type: "boolean" },
+				lastPublishedToAemPublish: {
+					type: "string",
+					format: "date-time"
+				},
+				lastPublishedToDynamicMedia: {
+					type: "string",
+					format: "date-time"
+				},
+				"aem:published": {
+					type: "string",
+					format: "date-time"
+				},
+				"aem:assetState": { type: "string" },
+				"aem:checkedOutBy": { type: "string" },
+				"repo:state": { type: "string" },
+				"repo:repositoryId": { type: "string" },
+				"repo:etag": { type: "string" },
+				"repo:scene7Domain": { type: "string" },
+				"repo:scene7File": { type: "string" },
+				"repo:scene7FileStatus": { type: "string" },
+				"repo:scene7Folder": { type: "string" },
+				"repo:scene7FontStyle": { type: "string" },
+				"repo:scene7FontType": { type: "string" },
+				"repo:scene7LastModified": { type: "string" },
+				"repo:scene7Name": { type: "string" },
+				"repo:scene7RTFName": { type: "string" },
+				"repo:scene7Type": { type: "string" }
+			},
+			additionalProperties: true
+		},
+		assetMetadata: {
+			type: "object",
+			properties: {
+				"xcm:keywords": {
+					type: "array",
+					items: {
+						type: "object",
+						properties: {
+							tagId: { type: "string" },
+							ancestorIds: {
+								type: "array",
+								items: { type: "string" }
+							},
+							value: { type: "string" },
+							"repo:ancestors": {
+								type: "array",
+								items: { type: "string" }
+							},
+							"@lang": { type: "string" }
+						}
+					}
+				},
+				"dc:creator": {
+					type: "array",
+					items: { type: "string" }
+				},
+				"dc:description": {
+					type: ["string", "array"],
+					items: { type: "string" }
+				},
+				"dc:title": {
+					type: ["string", "array"],
+					items: { type: "string" }
+				},
+				"exif:GPSLatitude": { type: "string" },
+				"exif:GPSLongitude": { type: "string" },
+				"photoshop:ColorMode": { type: "number" },
+				"photoshop:DateCreated": {
+					type: "string",
+					format: "date-time"
+				},
+				"xcm:machineKeywords": {
+					type: "array",
+					items: {
+						type: "object",
+						properties: {
+							value: { type: "string" },
+							confidence: { type: "number" },
+							localeCode: { type: "string" }
+						}
+					}
+				},
+				"tiff:BitsPerSample": {
+					type: "array",
+					items: { type: "integer" }
+				},
+				"tiff:Orientation": { type: "number" },
+				"xmp:CreateDate": {
+					type: "string",
+					format: "date-time"
+				},
+				"xmp:CreatorTool": { type: "string" },
+				"xmp:ModifyDate": {
+					type: "string",
+					format: "date-time"
+				}
+			},
+			additionalProperties: true
+		}
+	}
+};
+const commandResultMessageSchema = {
+	type: "object",
+	properties: {
+		type: { type: "string" },
+		title: { type: "string" },
+		detail: { type: "string" },
+		context: { type: "object" }
+	},
+	required: ["type", "title"]
+};
+const folderListingItemSchema = {
+	type: "object",
+	properties: {
+		type: {
+			type: "string",
+			enum: ["FOLDER", "ASSET"]
+		},
+		folderId: { type: "string" },
+		assetId: { type: "string" },
+		name: { type: "string" },
+		title: { type: ["string", "null"] },
+		path: { type: "string" },
+		size: { type: "integer" },
+		lastModifiedAt: {
+			type: "string",
+			format: "date-time"
+		}
+	},
+	required: ["type"]
+};
+const jobStateSchema = {
+	type: "string",
+	enum: [
+		"QUEUED",
+		"PROCESSING",
+		"COMPLETED",
+		"COMPLETED_WITH_ERRORS",
+		"FAILED"
+	]
+};
+//#endregion
+//#region src/outputSchemas/assets.ts
+const searchAssetsOutputSchema = {
+	type: "object",
+	properties: {
+		hits: {
+			type: "object",
+			properties: { results: {
+				type: "array",
+				items: assetMetadataResourceSchema
+			} }
+		},
+		cursor: { type: "string" },
+		facets: {
+			type: "array",
+			items: {
+				type: "object",
+				properties: {
+					type: {
+						type: "string",
+						enum: ["CATEGORY", "STAT"]
+					},
+					field: { type: "string" },
+					id: { type: "string" },
+					values: {
+						type: ["array", "object"],
+						items: {
+							type: "object",
+							properties: {
+								value: { type: "string" },
+								count: { type: "integer" }
+							},
+							required: ["value", "count"]
+						},
+						properties: {
+							min: { type: "string" },
+							max: { type: "string" }
+						}
+					}
+				},
+				required: [
+					"id",
+					"field",
+					"type"
+				]
+			}
+		},
+		search_metadata: {
+			type: "object",
+			properties: {
+				count: { type: "integer" },
+				totalCount: {
+					type: "object",
+					properties: {
+						total: { type: "integer" },
+						relation: {
+							type: "string",
+							enum: ["eq", "gte"]
+						}
+					}
+				},
+				searchDuration: { type: "integer" }
+			}
+		}
+	}
+};
+const getAssetMetadataOutputSchema = assetMetadataResourceSchema;
+const listAssetRenditionsOutputSchema = {
+	type: "object",
+	properties: {
+		assetId: { type: "string" },
+		"repo:name": { type: "string" },
+		items: {
+			type: "array",
+			items: {
+				type: "object",
+				properties: {
+					name: { type: "string" },
+					format: { type: "string" },
+					size: { type: "integer" },
+					dimensions: {
+						type: "object",
+						properties: {
+							width: { type: "integer" },
+							height: { type: "integer" }
+						}
+					}
+				},
+				required: [
+					"name",
+					"size",
+					"format"
+				]
+			}
+		}
+	},
+	required: [
+		"assetId",
+		"items",
+		"repo:name"
+	]
+};
+const aemJobOutputSchema = {
+	type: "object",
+	properties: {
+		jobId: { type: "string" },
+		state: jobStateSchema,
+		status: { type: "string" }
+	},
+	required: ["jobId", "state"]
+};
+const deleteAssetOutputSchema = {
+	type: "object",
+	properties: {
+		jobId: { type: "string" },
+		state: jobStateSchema,
+		status: { type: "string" },
+		assetId: { type: "string" },
+		deleted: { type: "boolean" }
+	}
+};
+const importJobProgressSchema = {
+	type: "object",
+	properties: {
+		failed: { type: "integer" },
+		imported: { type: "integer" },
+		lastImported: { type: "string" },
+		lastUpdated: {
+			type: "string",
+			format: "date-time"
+		},
+		skipped: { type: "number" },
+		started: {
+			type: "string",
+			format: "date-time"
+		},
+		total: { type: "number" },
+		size: { type: "number" },
+		step: {
+			type: "string",
+			enum: [
+				"QUEUED",
+				"SCANNING",
+				"IMPORTING",
+				"DONE"
+			]
+		},
+		transferred: { type: "number" }
+	},
+	required: [
+		"failed",
+		"imported",
+		"lastUpdated",
+		"skipped",
+		"started",
+		"size",
+		"step",
+		"total",
+		"transferred"
+	]
+};
+const importJobOutputSchema = {
+	type: "object",
+	properties: {
+		id: { type: "string" },
+		operation: {
+			type: "string",
+			enum: ["aem.assets.import.fromurl"]
+		},
+		state: {
+			type: "string",
+			enum: [
+				"PROCESSING",
+				"COMPLETED",
+				"FAILED"
+			]
+		},
+		status: { type: "number" },
+		description: { type: "string" },
+		progress: importJobProgressSchema,
+		data: {
+			type: "object",
+			properties: {
+				id: { type: "string" },
+				config: {
+					type: "object",
+					properties: {
+						folder: { type: "string" },
+						items: {
+							type: "array",
+							items: { type: "string" }
+						},
+						assetMetadata: {
+							type: "object",
+							additionalProperties: true
+						}
+					},
+					required: ["folder", "items"]
+				},
+				processedFiles: {
+					type: "array",
+					items: { type: "object" }
+				},
+				progress: importJobProgressSchema
+			},
+			required: [
+				"id",
+				"config",
+				"progress"
+			]
+		},
+		errors: {
+			type: "array",
+			items: commandResultMessageSchema
+		},
+		warnings: {
+			type: "array",
+			items: commandResultMessageSchema
+		}
+	}
+};
+const listContentFragmentsOutputSchema = {
+	type: "object",
+	properties: {
+		items: {
+			type: "array",
+			items: {
+				...contentFragmentSchema,
+				properties: {
+					...contentFragmentSchema.properties,
+					etag: { type: "string" },
+					tagsCount: { type: "integer" }
+				},
+				required: [],
+				additionalProperties: true
+			}
+		},
+		cursor: {
+			type: "string",
+			description: "Present when more pages remain."
+		}
+	},
+	required: ["items"]
+};
+const searchContentFragmentsOutputSchema = listContentFragmentsOutputSchema;
+const getContentFragmentOutputSchema = contentFragmentSchema;
+const listContentFragmentVariationsOutputSchema = {
+	type: "object",
+	properties: {
+		items: {
+			type: "array",
+			items: contentFragmentVariationSchema
+		},
+		cursor: { type: "string" }
+	},
+	required: ["items"]
+};
+const listContentFragmentModelsOutputSchema = {
+	type: "object",
+	properties: {
+		items: {
+			type: "array",
+			items: contentFragmentModelSchema
+		},
+		cursor: { type: "string" }
+	},
+	required: ["items"]
+};
+//#endregion
+//#region src/outputSchemas/folders.ts
+const listFolderContentsOutputSchema = {
+	type: "object",
+	properties: {
+		self: folderListingItemSchema,
+		children: {
+			type: "array",
+			items: folderListingItemSchema
+		},
+		cursor: { type: "string" }
+	}
+};
+const listAssetsInFolderTreeOutputSchema = {
+	type: "array",
+	items: {
+		...folderListingItemSchema,
+		properties: {
+			...folderListingItemSchema.properties,
+			folderPath: { type: "string" }
+		},
+		required: ["type", "folderPath"]
+	}
+};
+const failedFolderItemSchema = {
+	type: "object",
+	properties: {
+		path: { type: "string" },
+		id: { type: "string" },
+		type: { type: "string" },
+		title: { type: "string" },
+		detail: { type: "string" },
+		context: { type: "object" }
+	},
+	required: ["type", "title"]
+};
+const folderCommandOutputSchema = (data) => ({
+	type: "object",
+	properties: {
+		jobId: { type: "string" },
+		state: jobStateSchema,
+		status: { type: ["string", "integer"] },
+		operation: { type: "string" },
+		description: { type: "string" },
+		data,
+		errors: {
+			type: "array",
+			items: commandResultMessageSchema
+		},
+		warnings: {
+			type: "array",
+			items: commandResultMessageSchema
+		}
+	}
+});
+const createFoldersOutputSchema = folderCommandOutputSchema({
+	type: "object",
+	properties: { values: {
+		type: "object",
+		properties: {
+			successes: {
+				type: "array",
+				items: {
+					type: "object",
+					properties: {
+						type: {
+							type: "string",
+							enum: ["FOLDER", "ASSET"]
+						},
+						folderId: { type: "string" },
+						name: { type: "string" },
+						title: { type: ["string", "null"] },
+						path: { type: "string" }
+					},
+					required: [
+						"type",
+						"folderId",
+						"name",
+						"path"
+					]
+				}
+			},
+			failedFolders: {
+				type: "array",
+				items: failedFolderItemSchema
+			}
+		}
+	} }
+});
+const deleteFoldersOutputSchema = folderCommandOutputSchema({
+	type: "object",
+	properties: {
+		deletedFolders: {
+			type: "array",
+			items: { type: "string" }
+		},
+		failedFolders: {
+			type: "array",
+			items: failedFolderItemSchema
+		}
+	}
+});
+//#endregion
+//#region src/outputSchemas/pages.ts
+const listSitemapUrlsOutputSchema = {
+	type: "array",
+	items: {
+		type: "object",
+		properties: {
+			loc: {
+				type: "string",
+				format: "uri"
+			},
+			lastmod: {
+				type: ["string", "null"],
+				format: "date-time"
+			}
+		},
+		required: ["loc", "lastmod"]
+	}
+};
+const getPublishedPageHtmlOutputSchema = {
+	type: "object",
+	properties: {
+		url: {
+			type: "string",
+			format: "uri"
+		},
+		finalUrl: {
+			type: "string",
+			format: "uri"
+		},
+		statusCode: { type: "integer" },
+		contentType: { type: ["string", "null"] },
+		lastModified: { type: ["string", "null"] },
+		etag: { type: ["string", "null"] },
+		html: { type: "string" }
+	},
+	required: [
+		"url",
+		"finalUrl",
+		"statusCode",
+		"html"
+	]
+};
+//#endregion
+//#region src/actions/assets/deleteAsset.ts
+const deleteAsset = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Delete Asset",
+		description: "Delete an asset. Usually completes immediately; when AEM runs the delete as a job, returns a job ID to check with Get Asset Job Status."
+	},
+	performSafety: "notAllowed",
+	perform: async (context, { connection, assetId, force }) => {
+		const { data, status } = await createAemClient(connection, context.debug.enabled).delete(`${ASSETS_API_PATH}/${encodeURIComponent(assetId)}`, { params: { force } });
+		return { data: status === 204 ? {
+			assetId,
+			deleted: true
+		} : data };
+	},
+	inputs: deleteAssetInputs,
+	outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+		type: "actionOutput",
+		schema: deleteAssetOutputSchema
+	}),
+	examplePerform: async () => deleteAssetExamplePayload,
+	examplePayload: deleteAssetExamplePayload
+});
+//#endregion
+//#region src/utils/assetFilters.ts
+const buildAssetFilterClauses = ({ folderIds, mimeTypes }) => [...folderIds.length ? [{ term: { [ASSET_ANCESTORS_FIELD]: folderIds } }] : [], ...mimeTypes.length ? [{ term: { [ASSET_FORMAT_FIELD]: mimeTypes } }] : []];
+//#endregion
+//#region src/utils/contentFragmentFilters.ts
+const buildContentFragmentTriggerFilter = (params) => ({
+	path: params.path,
+	status: params.statuses.length ? params.statuses : void 0,
+	modelIds: params.modelIds.length ? params.modelIds : void 0,
+	tags: params.tags.length ? params.tags : void 0,
+	locale: params.locales.length ? params.locales : void 0
+});
+const toTimeInterval = (after, before) => after || before ? {
+	after,
+	before
+} : void 0;
+//#endregion
+//#region src/utils/downloads.ts
+const toDownloadedFile = (response) => ({
+	data: Buffer.from(response.data),
+	contentType: typeof response.headers["content-type"] === "string" ? response.headers["content-type"] : "application/octet-stream"
+});
+//#endregion
+//#region src/utils/elements.ts
+const compareElementLabels = (a, b) => _prismatic_io_spectral.util.types.toString(a.label ?? a.key).localeCompare(_prismatic_io_spectral.util.types.toString(b.label ?? b.key));
+//#endregion
+//#region src/utils/records.ts
+const toPublishUrl = (publishBaseUrl, path) => publishBaseUrl && path ? `${publishBaseUrl}${path}` : null;
+const toContentFragmentRecord = (fragment, scope, publishBaseUrl) => ({
+	resourceType: "contentFragment",
+	id: fragment.id,
+	path: fragment.path ?? null,
+	url: toPublishUrl(publishBaseUrl, fragment.path ?? null),
+	title: fragment.title ?? null,
+	tags: (fragment.tags ?? []).map((tag) => ({
+		id: tag.id,
+		title: tag.title ?? null,
+		titlePath: tag.titlePath ?? null
+	})),
+	created: fragment.created?.at ?? null,
+	modified: fragment.modified?.at ?? null,
+	published: fragment.published?.at ?? null,
+	scope,
+	data: fragment
+});
+const toAssetRecord = (hit, scope, publishBaseUrl) => {
+	const repo = hit.repositoryMetadata ?? {};
+	const meta = hit.assetMetadata ?? {};
+	const path = repo["repo:path"] ?? null;
+	const keywords = Array.isArray(meta["xcm:keywords"]) ? meta["xcm:keywords"] : [];
+	return {
+		resourceType: "asset",
+		id: hit.assetId,
+		path,
+		url: toPublishUrl(publishBaseUrl, path),
+		title: typeof meta["dc:title"] === "string" ? meta["dc:title"] : repo["repo:name"] ?? null,
+		tags: keywords.map((keyword) => {
+			const entry = keyword;
+			return {
+				id: entry.tagId ?? entry.value ?? _prismatic_io_spectral.util.types.toString(keyword),
+				title: entry.value ? entry.value.split(/\s*[/:]\s*/).pop() ?? null : null,
+				titlePath: entry.value ?? null
+			};
+		}),
+		created: repo["repo:createDate"] ?? null,
+		modified: repo["repo:modifyDate"] ?? null,
+		published: repo["aem:published"] ?? null,
+		scope,
+		data: hit
+	};
+};
+//#endregion
+//#region src/utils/events.ts
+const RESOURCE_PREFIXES = [
+	["aem.sites.contentFragment.", "contentFragment"],
+	["aem.sites.page.", "page"],
+	["aem.assets.asset.", "asset"]
+];
+const ACTION_CHANGE_TYPES = {
+	created: "created",
+	modified: "modified",
+	published: "published",
+	unpublished: "unpublished",
+	deleted: "deleted",
+	processing_completed: "created",
+	metadata_updated: "modified"
+};
+const asString = (value) => typeof value === "string" ? value : null;
+const asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+const asResourceUrl = (value) => {
+	const url = asString(value);
+	if (!url) return null;
+	try {
+		return new URL(url).pathname.length > 1 ? url : null;
+	} catch {
+		return null;
+	}
+};
+const parseAemCloudEvent = (body, rawBody) => {
+	if (body && typeof body === "object" && !Array.isArray(body) && !(body instanceof Uint8Array)) return body;
+	try {
+		const parsed = JSON.parse(rawBody);
+		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+	} catch {}
+	throw new Error("Adobe I/O Events delivered a body that is not a JSON CloudEvent.");
+};
+const toAemEventItem = (event, scope, publishBaseUrl) => {
+	const code = event.type ?? "";
+	const prefix = RESOURCE_PREFIXES.find(([value]) => code.startsWith(value));
+	const resourceType = prefix?.[1] ?? "unknown";
+	const action = prefix ? code.slice(prefix[0].length) : code.split(".").pop() ?? "";
+	const data = event.data ?? {};
+	const repository = asRecord(data.repositoryMetadata);
+	const path = asString(data.path) ?? asString(repository["repo:path"]);
+	const id = asString(data.id) ?? asString(repository["repo:assetId"]) ?? path ?? event.id ?? "";
+	return {
+		changeType: ACTION_CHANGE_TYPES[action] ?? "modified",
+		record: {
+			resourceType,
+			id,
+			path,
+			url: asResourceUrl(data.sourceUrl) ?? toPublishUrl(publishBaseUrl, resourceType === "page" && path ? `${path}.html` : path),
+			title: asString(data.title) ?? asString(asRecord(data.assetMetadata)["dc:title"]),
+			tags: (Array.isArray(data.tags) ? data.tags : []).map((tag) => ({
+				id: _prismatic_io_spectral.util.types.toString(tag),
+				title: null,
+				titlePath: null
+			})),
+			created: null,
+			modified: event.time ?? null,
+			published: null,
+			scope,
+			data: event
+		},
+		eventId: event.id ?? null,
+		eventSource: event.source ?? null,
+		eventType: event.type ?? null
+	};
+};
+//#endregion
+//#region src/utils/signature.ts
+const keyCache = /* @__PURE__ */ new Map();
+const getPublicKey = async (client, keyPath) => {
+	const cached = keyCache.get(keyPath);
+	if (cached && Date.now() - cached.fetchedAt < 864e5) return cached.pem;
+	const { data } = await client.get(`${IO_EVENTS_PUBLIC_KEY_BASE_URL}${keyPath}`);
+	const pem = _prismatic_io_spectral.util.types.toString(data);
+	keyCache.set(keyPath, {
+		pem,
+		fetchedAt: Date.now()
+	});
+	return pem;
+};
+const verifyOne = (rawBody, signature, pem) => {
+	try {
+		const verifier = (0, node_crypto.createVerify)("RSA-SHA256");
+		verifier.update(rawBody);
+		return verifier.verify(pem, signature, "base64");
+	} catch {
+		return false;
+	}
+};
+const verifyAdobeSignature = async (client, headers, rawBody) => {
+	const pairs = [[headers["x-adobe-digital-signature-1"], headers["x-adobe-public-key1-path"]], [headers["x-adobe-digital-signature-2"], headers["x-adobe-public-key2-path"]]].filter((pair) => pair[0] !== void 0 && pair[0] !== "" && pair[1] !== void 0 && pair[1] !== "");
+	for (const [signature, keyPath] of pairs) {
+		if (!keyPath.startsWith("/")) continue;
+		let pem;
+		try {
+			pem = await getPublicKey(client, keyPath);
+		} catch {
+			continue;
+		}
+		if (verifyOne(rawBody, signature, pem)) return;
+	}
+	throw new Error("Adobe I/O Events signature verification failed.");
+};
+//#endregion
+//#region src/utils/webhooks.ts
+const workspacePath = ({ consumerOrgId, projectId, workspaceId }) => `/${encodeURIComponent(consumerOrgId)}/${encodeURIComponent(projectId)}/${encodeURIComponent(workspaceId)}`;
+const webhookStateKey = (context) => `aemEventSubscription:${context.flow.id}`;
+const getWebhookUrl = (context) => context.webhookUrls[context.flow.name];
+const sameConfig = (state, params) => state.previousWorkspace === workspacePath(params) && state.previousProviderId === params.providerId && state.previousClientId === _prismatic_io_spectral.util.types.toString(params.connection.fields.clientId) && [...state.previousEventTypes].sort().join(",") === [...params.eventTypes].sort().join(",");
+const deleteRegistrationsForUrl = async (client, params, webhookUrl) => {
+	const base = `${workspacePath(params)}/registrations`;
+	const { data } = await client.get(base);
+	const matches = (data._embedded?.registrations ?? []).filter((registration) => registration.webhook_url === webhookUrl);
+	for (const registration of matches) await client.delete(`${base}/${encodeURIComponent(registration.registration_id)}`);
+	return matches.length;
+};
+const ensureRegistration = async (context, client, params) => {
+	const webhookUrl = getWebhookUrl(context);
+	const existing = context.crossFlowState[webhookStateKey(context)];
+	if (existing?.registrationId && sameConfig(existing, params)) {
+		context.logger.info("AEM event registration already exists with the same settings; skipping.");
+		return;
+	}
+	const oldParams = existing ? (() => {
+		const [, org, project, workspace] = existing.previousWorkspace.split("/");
+		return {
+			...params,
+			consumerOrgId: decodeURIComponent(org),
+			projectId: decodeURIComponent(project),
+			workspaceId: decodeURIComponent(workspace)
+		};
+	})() : params;
+	let removed = await deleteRegistrationsForUrl(client, oldParams, webhookUrl);
+	if (workspacePath(oldParams) !== workspacePath(params)) removed += await deleteRegistrationsForUrl(client, params, webhookUrl);
+	context.logger.info(existing ? `Settings changed; removed ${removed} AEM event registration(s) and recreating.` : `Creating AEM event registration (removed ${removed} stale registration(s) for this URL).`);
+	const { data } = await client.post(`${workspacePath(params)}/registrations`, {
+		client_id: _prismatic_io_spectral.util.types.toString(params.connection.fields.clientId),
+		name: `AEM events: ${context.flow.name}`.slice(0, 80),
+		description: "Adobe Experience Manager events for an integration flow.",
+		delivery_type: "webhook",
+		webhook_url: webhookUrl,
+		events_of_interest: params.eventTypes.map((eventCode) => ({
+			provider_id: params.providerId,
+			event_code: eventCode
+		})),
+		enabled: true
+	});
+	return {
+		registrationId: data.registration_id,
+		previousClientId: _prismatic_io_spectral.util.types.toString(params.connection.fields.clientId),
+		previousEventTypes: params.eventTypes,
+		previousProviderId: params.providerId,
+		previousWorkspace: workspacePath(params)
+	};
+};
+//#endregion
+//#region src/utils/eventTriggers.ts
+const aemEventLifecycleHandlers = (label) => ({
+	create: async (context, params) => {
+		if (!isIoEventsConnection(params.connection)) throw new Error(`${label} requires the OAuth 2.0 Client Credentials connection. Adobe I/O Events registrations are documented for OAuth Server-to-Server credentials only.`);
+		if (!params.eventTypes.length) throw new Error(`${label} needs at least one event type. Select the events to subscribe to in Event Types.`);
+		const state = await ensureRegistration(context, createIoEventsClient(params.connection, context.debug.enabled), params);
+		return state ? { crossFlowState: { [webhookStateKey(context)]: state } } : void 0;
+	},
+	delete: async (context, params) => {
+		if (!isIoEventsConnection(params.connection)) return { crossFlowState: { [webhookStateKey(context)]: null } };
+		await deleteRegistrationsForUrl(createIoEventsClient(params.connection, context.debug.enabled), params, getWebhookUrl(context));
+		return { crossFlowState: { [webhookStateKey(context)]: null } };
+	}
+});
+const performAemEvent = async (context, payload, params) => {
+	const challenge = payload.queryParameters?.challenge;
+	if (challenge) return {
+		payload: {
+			...payload,
+			body: { data: null }
+		},
+		branch: "URL Verification",
+		response: {
+			statusCode: 200,
+			contentType: "text/plain",
+			body: challenge
+		}
+	};
+	const rawBody = _prismatic_io_spectral.util.types.toString(payload.rawBody.data);
+	const event = parseAemCloudEvent(payload.body.data, rawBody);
+	if (!context.isSimulatedTestExecution) {
+		const headers = _prismatic_io_spectral.util.types.lowerCaseHeaders(payload.headers);
+		await verifyAdobeSignature(createPublicClient(context.debug.enabled), headers, rawBody);
+		const clientId = _prismatic_io_spectral.util.types.toString(params.connection.fields.clientId);
+		if (event.recipientclientid && event.recipientclientid !== clientId) throw new Error("AEM event was addressed to a different Adobe client ID.");
+	}
+	const item = toAemEventItem(event, params.workspaceId, params.publishBaseUrl);
+	return {
+		payload: {
+			...payload,
+			body: { data: item }
+		},
+		branch: "Notification"
+	};
+};
+//#endregion
+//#region src/utils/folders.ts
+const isAemJob = (value) => typeof value === "object" && value !== null && "jobId" in value;
+const assertFolderCommandProgress = (result, succeeded, failures) => {
+	if (succeeded === 0 && failures.length) {
+		const reasons = failures.map((f) => f.detail ?? f.title ?? f.path ?? "unknown error");
+		const summary = "description" in result ? result.description : void 0;
+		throw new Error(`${summary ?? "The folder request failed."} ${reasons.join("; ")}`);
+	}
+	return result;
+};
+const walkFolderTree = async (client, rootPath, { collectAssets, maxFolders = MAX_FOLDER_WALK }) => {
+	const tree = {
+		folders: [],
+		assets: [],
+		truncated: false
+	};
+	const queue = [rootPath];
+	let visited = 0;
+	while (queue.length && visited < maxFolders) {
+		const folderPath = queue.shift();
+		visited++;
+		let cursor;
+		do {
+			const { data } = await client.get(`${FOLDERS_API_PATH}/`, { params: {
+				path: folderPath,
+				types: collectAssets ? "FOLDER,ASSET" : "FOLDER",
+				limit: 50,
+				cursor
+			} });
+			for (const child of data.children ?? []) if (child.type === "FOLDER") {
+				tree.folders.push(child);
+				queue.push(child.path);
+			} else if (collectAssets) tree.assets.push({
+				...child,
+				folderPath
+			});
+			cursor = data.cursor;
+		} while (cursor);
+	}
+	tree.truncated = queue.length > 0;
+	return tree;
+};
+//#endregion
+//#region src/utils/metadata.ts
+const toPointerSegment = (field) => field.replace(/~/g, "~0").replace(/\//g, "~1");
+const buildMetadataPatch = (values, removals) => {
+	const operations = [...Object.entries(values).map(([field, value]) => ({
+		op: "add",
+		path: `/${toPointerSegment(field)}`,
+		value
+	})), ...removals.map((field) => ({
+		op: "remove",
+		path: `/${toPointerSegment(field)}`
+	}))];
+	if (!operations.length) throw new Error("Update Asset Metadata needs at least one metadata value or field to remove.");
+	return operations;
+};
+//#endregion
+//#region src/utils/pagination.ts
+const fetchCursorPages = async (client, url, query, { fetchAll, cursor, limit }) => {
+	if (!fetchAll) {
+		const { data } = await client.get(url, { params: {
+			...query,
+			cursor,
+			limit
+		} });
+		return {
+			items: data.items ?? [],
+			cursor: data.cursor
+		};
+	}
+	const items = [];
+	let next = cursor;
+	let pages = 0;
+	do {
+		const { data } = await client.get(url, { params: {
+			...query,
+			cursor: next,
+			limit: 50
+		} });
+		items.push(...data.items ?? []);
+		next = data.cursor;
+		pages++;
+	} while (next && pages < 500);
+	return {
+		items,
+		cursor: next
+	};
+};
+//#endregion
+//#region src/utils/polling.ts
+const windowNow = (nowMs = Date.now()) => (/* @__PURE__ */ new Date(nowMs - SETTLE_LAG_MS)).toISOString();
+const resolvePollWindow = (state, incoming, lookBackDate, now) => {
+	const resume = incoming ?? state.cursor;
+	const isInitialSync = state.lastPolledAt === void 0 && lookBackDate !== "";
+	if (resume) return {
+		windowStart: resume.windowStart,
+		windowEnd: resume.windowEnd,
+		cursor: resume.cursor,
+		isInitialSync
+	};
+	return {
+		windowStart: state.lastPolledAt ?? (lookBackDate || now),
+		windowEnd: now,
+		isInitialSync
+	};
+};
+const nextPollingState = (state, window, nextCursor) => nextCursor ? {
+	...state.lastPolledAt ? { lastPolledAt: state.lastPolledAt } : {},
+	cursor: nextCursor
+} : { lastPolledAt: window.windowEnd };
+const readWindow = async (readPage, startCursor, isBatching) => {
+	const maxPages = isBatching ? 1 : 20;
+	const records = [];
+	let cursor = startCursor;
+	for (let page = 0; page < maxPages; page++) {
+		const result = await readPage(cursor);
+		records.push(...result.records);
+		cursor = result.cursor;
+		if (!cursor) break;
+	}
+	return {
+		records,
+		cursor
+	};
+};
+const isInWindow = (value, window) => {
+	if (!value) return false;
+	const time = toIsoDate(value).getTime();
+	return time >= toIsoDate(window.windowStart).getTime() && time < toIsoDate(window.windowEnd).getTime();
+};
+const listChangedContentFragments = async (client, baseFilter, window, isBatching) => {
+	const after = (/* @__PURE__ */ new Date(toIsoDate(window.windowStart).getTime() - 1)).toISOString();
+	const before = new Date(toIsoDate(window.windowEnd).getTime() + 1).toISOString();
+	const query = JSON.stringify({
+		filter: {
+			...baseFilter,
+			modifiedOrCreated: {
+				after,
+				before
+			}
+		},
+		sort: [{
+			on: "modifiedOrCreated",
+			order: "ASC"
+		}]
+	});
+	const result = await readWindow(async (cursor) => {
+		const { data } = await client.get(`${SITES_API_PATH}/cf/fragments/search`, { params: {
+			query,
+			cursor,
+			limit: 50
+		} });
+		return {
+			records: data.items ?? [],
+			cursor: data.cursor
+		};
+	}, window.cursor, isBatching);
+	return {
+		records: result.records.filter((fragment) => isInWindow(fragment.modified?.at ?? fragment.created?.at, window)),
+		cursor: result.cursor
+	};
+};
+const listChangedAssets = async (client, filters, window, isBatching) => readWindow(async (cursor) => {
+	const body = {
+		query: [...buildAssetFilterClauses(filters), { range: { [ASSET_MODIFY_DATE_FIELD]: {
+			gte: window.windowStart,
+			lt: window.windowEnd
+		} } }],
+		sort: [{
+			field: ASSET_MODIFY_DATE_FIELD,
+			order: "ASC"
+		}],
+		limit: 50,
+		cursor
+	};
+	const { data } = await client.post(`${ASSETS_API_PATH}/search`, body);
+	return {
+		records: data.hits?.results ?? [],
+		cursor: data.cursor
+	};
+}, window.cursor, isBatching);
+const classifyChange = (record, windowStart, isInitialSync) => {
+	if (isInitialSync) return "initialSync";
+	const start = toIsoDate(windowStart).getTime();
+	const isAfterStart = (value) => value !== null && toIsoDate(value).getTime() >= start;
+	if (isAfterStart(record.created)) return "created";
+	if (isAfterStart(record.published)) return "published";
+	return "modified";
+};
+const resolveAemChangeItems = (data) => {
+	return [...(data ?? {}).items ?? []];
+};
+//#endregion
+//#region src/utils/sitemap.ts
+const XML_ENTITIES = {
+	"&amp;": "&",
+	"&lt;": "<",
+	"&gt;": ">",
+	"&quot;": "\"",
+	"&apos;": "'"
+};
+const decodeXml = (value) => value.replace(/^<!\[CDATA\[([\s\S]*)\]\]>$/, "$1").replace(/&(amp|lt|gt|quot|apos);/g, (entity) => XML_ENTITIES[entity] ?? entity).trim();
+const readTag = (block, tag) => {
+	const match = block.match(new RegExp(`<(?:\\w+:)?${tag}[^>]*>([\\s\\S]*?)</(?:\\w+:)?${tag}>`));
+	return match ? decodeXml(match[1]) : null;
+};
+const readBlocks = (xml, tag) => xml.match(new RegExp(`<(?:\\w+:)?${tag}[\\s>][\\s\\S]*?</(?:\\w+:)?${tag}>`, "g")) ?? [];
+const parseSitemap = (xml) => {
+	const toIsoOrNull = (value) => {
+		if (value === null || value === "") return null;
+		try {
+			return toIsoDate(value).toISOString();
+		} catch {
+			return null;
+		}
+	};
+	return {
+		sitemaps: readBlocks(xml, "sitemap").map((block) => readTag(block, "loc")).filter((loc) => loc !== null && loc !== ""),
+		pages: readBlocks(xml, "url").map((block) => ({
+			loc: readTag(block, "loc"),
+			lastmod: toIsoOrNull(readTag(block, "lastmod"))
+		})).filter((page) => page.loc !== null && page.loc !== "")
+	};
+};
+const filterPages = (pages, { modifiedAfter, includePathPrefixes = [], excludePathPrefixes = [] }) => pages.filter((page) => {
+	let path;
+	try {
+		path = new URL(page.loc).pathname;
+	} catch {
+		return false;
+	}
+	if (includePathPrefixes.length && !includePathPrefixes.some((prefix) => path.startsWith(prefix))) return false;
+	if (excludePathPrefixes.some((prefix) => path.startsWith(prefix))) return false;
+	if (!modifiedAfter) return true;
+	return page.lastmod !== null && toIsoDate(page.lastmod) > toIsoDate(modifiedAfter);
+});
+//#endregion
+//#region src/actions/assets/index.ts
+var assets_default = {
+	deleteAsset,
+	downloadAsset: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Download Asset",
+			description: "Download the original binary of an asset."
+		},
+		performSafety: "notAllowed",
+		perform: async (context, { connection, assetId, seoName }) => {
+			return toDownloadedFile(await createAemDownloadClient(connection, context.debug.enabled).get(`${ASSETS_API_PATH}/${encodeURIComponent(assetId)}/original/as/${encodeURIComponent(seoName)}`));
+		},
+		inputs: downloadAssetInputs,
+		examplePerform: async () => downloadAssetExamplePayload,
+		examplePayload: downloadAssetExamplePayload
+	}),
+	downloadAssetRendition: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Download Asset Rendition",
+			description: "Download a rendition of an asset, such as a web-optimized image or text version."
+		},
+		performSafety: "notAllowed",
+		perform: async (context, { connection, assetId, renditionName, seoName }) => {
+			return toDownloadedFile(await createAemDownloadClient(connection, context.debug.enabled).get(`${ASSETS_API_PATH}/${encodeURIComponent(assetId)}/renditions/${encodeURIComponent(renditionName)}/as/${encodeURIComponent(seoName)}`));
+		},
+		inputs: downloadAssetRenditionInputs,
+		examplePerform: async () => downloadAssetRenditionExamplePayload,
+		examplePayload: downloadAssetRenditionExamplePayload
+	}),
+	getAssetJobStatus: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Get Asset Job Status",
+			description: "Retrieve the state of a Delete Asset job."
+		},
+		performSafety: "safe",
+		perform: async (context, { connection, jobId }) => {
+			const { data } = await createAemClient(connection, context.debug.enabled).get(`${ASSETS_API_PATH}/jobs/${encodeURIComponent(jobId)}/status`);
+			return { data };
+		},
+		inputs: getAssetJobStatusInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: aemJobOutputSchema
+		}),
+		examplePayload: getAssetJobStatusExamplePayload
+	}),
+	getAssetMetadata: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Get Asset Metadata",
+			description: "Retrieve the repository and asset metadata of an asset."
+		},
+		performSafety: "safe",
+		perform: async (context, { connection, assetId }) => {
+			const { data } = await createAemClient(connection, context.debug.enabled).get(`${ASSETS_API_PATH}/${encodeURIComponent(assetId)}/metadata`);
+			return { data };
+		},
+		inputs: getAssetMetadataInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: getAssetMetadataOutputSchema
+		}),
+		examplePayload: getAssetMetadataExamplePayload
+	}),
+	getImportJobStatus: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Get Import Job Status",
+			description: "Retrieve the state and progress of an Import Asset from URL job."
+		},
+		performSafety: "safe",
+		perform: async (context, { connection, jobId }) => {
+			const { data } = await createAemClient(connection, context.debug.enabled).get(`${ASSETS_API_PATH}/import/jobs/${encodeURIComponent(jobId)}/status`);
+			return { data };
+		},
+		inputs: getImportJobStatusInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: importJobOutputSchema
+		}),
+		examplePayload: getImportJobStatusExamplePayload
+	}),
+	importAssetFromUrl: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Import Asset from URL",
+			description: "Create an asset by having AEM download a file from a URL. Runs as a job; check it with Get Import Job Status."
+		},
+		performSafety: "notAllowed",
+		perform: async (context, { connection, folder, fileUrl, fileName, mimeType }) => {
+			const { data } = await createAemClient(connection, context.debug.enabled).post(`${ASSETS_API_PATH}/import/fromUrl`, {
+				folder,
+				files: [{
+					url: fileUrl,
+					fileName,
+					...mimeType ? { mimeType } : {}
+				}]
+			});
+			return { data };
+		},
+		inputs: importAssetFromUrlInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: importJobOutputSchema
+		}),
+		examplePerform: async () => importAssetFromUrlExamplePayload,
+		examplePayload: importAssetFromUrlExamplePayload
+	}),
+	listAssetRenditions: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "List Asset Renditions",
+			description: "List the renditions available for an asset."
+		},
+		performSafety: "notAllowed",
+		perform: async (context, { connection, assetId }) => {
+			const { data } = await createAemClient(connection, context.debug.enabled).get(`${ASSETS_API_PATH}/${encodeURIComponent(assetId)}/renditions`);
+			return { data };
+		},
+		inputs: listAssetRenditionsInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: listAssetRenditionsOutputSchema
+		}),
+		examplePerform: async () => listAssetRenditionsExamplePayload,
+		examplePayload: listAssetRenditionsExamplePayload
+	}),
+	searchAssets: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Search Assets",
+			description: "Search assets by folder, MIME type, modified date, and text."
+		},
+		performSafety: "notAllowed",
+		perform: async (context, params) => {
+			const client = createAemClient(params.connection, context.debug.enabled);
+			const range = params.modifiedAfter || params.modifiedBefore ? {
+				gte: params.modifiedAfter,
+				lt: params.modifiedBefore
+			} : void 0;
+			const query = [
+				{ match: { text: params.filters?.searchText ?? "" } },
+				...buildAssetFilterClauses(params),
+				...range ? [{ range: { [ASSET_MODIFY_DATE_FIELD]: range } }] : []
+			];
+			const sort = params.filters?.sortField ? [{
+				field: params.filters.sortField,
+				order: params.filters?.sortOrder === "DESC" ? "DESC" : "ASC"
+			}] : void 0;
+			if (!params.fetchAll) {
+				const { data } = await client.post(`${ASSETS_API_PATH}/search`, {
+					query,
+					sort,
+					limit: params.pagination?.limit,
+					cursor: params.pagination?.cursor
+				});
+				return { data };
+			}
+			const results = [];
+			let cursor = params.pagination?.cursor;
+			let pages = 0;
+			do {
+				const { data } = await client.post(`${ASSETS_API_PATH}/search`, {
+					query,
+					sort,
+					limit: 50,
+					cursor
+				});
+				results.push(...data.hits?.results ?? []);
+				cursor = data.cursor;
+				pages++;
+			} while (cursor && pages < 500);
+			return { data: {
+				hits: { results },
+				cursor
+			} };
+		},
+		inputs: searchAssetsInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: searchAssetsOutputSchema
+		}),
+		examplePerform: async () => searchAssetsExamplePayload,
+		examplePayload: searchAssetsExamplePayload
+	}),
+	updateAssetMetadata: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Update Asset Metadata",
+			description: "Set or remove asset metadata fields, such as dc:title, on an asset."
+		},
+		performSafety: "notAllowed",
+		perform: async (context, { connection, assetId, metadataValues, removeFields }) => {
+			const operations = buildMetadataPatch(metadataValues, removeFields);
+			const client = createAemClient(connection, context.debug.enabled);
+			const path = `${ASSETS_API_PATH}/${encodeURIComponent(assetId)}/metadata`;
+			const { data } = await client.patch(path, operations, { headers: {
+				"If-Match": "*",
+				"Content-Type": "application/json-patch+json"
+			} });
+			return { data };
+		},
+		inputs: updateAssetMetadataInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: getAssetMetadataOutputSchema
+		}),
+		examplePerform: async () => updateAssetMetadataExamplePayload,
+		examplePayload: updateAssetMetadataExamplePayload
+	})
+};
+//#endregion
+//#region src/actions/contentFragments/getContentFragment.ts
+const getContentFragment = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Get Content Fragment",
+		description: "Retrieve a content fragment by ID."
+	},
+	performSafety: "safe",
+	perform: async (context, { connection, fragmentId, includeMetadata, references }) => {
+		const { data } = await createAemClient(connection, context.debug.enabled).get(`${SITES_API_PATH}/cf/fragments/${encodeURIComponent(fragmentId)}`, { params: {
+			includeMetadata: includeMetadata || void 0,
+			references
+		} });
+		return { data };
+	},
+	inputs: getContentFragmentInputs,
+	outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+		type: "actionOutput",
+		schema: getContentFragmentOutputSchema
+	}),
+	examplePayload: getContentFragmentExamplePayload
+});
+//#endregion
+//#region src/actions/contentFragments/listContentFragmentModels.ts
+const listContentFragmentModels = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "List Content Fragment Models",
+		description: "List the content fragment models available in the environment."
+	},
+	performSafety: "notAllowed",
+	perform: async (context, params) => {
+		return { data: await fetchCursorPages(createAemClient(params.connection, context.debug.enabled), `${SITES_API_PATH}/cf/models`, { projection: params.projection }, {
+			fetchAll: params.fetchAll,
+			...params.pagination
+		}) };
+	},
+	inputs: listContentFragmentModelsInputs,
+	outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+		type: "actionOutput",
+		schema: listContentFragmentModelsOutputSchema
+	}),
+	examplePerform: async () => listContentFragmentModelsExamplePayload,
+	examplePayload: listContentFragmentModelsExamplePayload
+});
+//#endregion
+//#region src/actions/contentFragments/listContentFragments.ts
+const listContentFragments = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "List Content Fragments",
+		description: "List content fragments, optionally under a path."
+	},
+	performSafety: "notAllowed",
+	perform: async (context, params) => {
+		return { data: await fetchCursorPages(createAemClient(params.connection, context.debug.enabled), `${SITES_API_PATH}/cf/fragments`, {
+			path: params.path,
+			projection: params.projection,
+			includeMetadata: params.includeMetadata || void 0,
+			references: params.references
+		}, {
+			fetchAll: params.fetchAll,
+			...params.pagination
+		}) };
+	},
+	inputs: listContentFragmentsInputs,
+	outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+		type: "actionOutput",
+		schema: listContentFragmentsOutputSchema
+	}),
+	examplePerform: async () => listContentFragmentsExamplePayload,
+	examplePayload: listContentFragmentsExamplePayload
+});
+//#endregion
+//#region src/actions/contentFragments/index.ts
+var contentFragments_default = {
+	getContentFragment,
+	listContentFragmentModels,
+	listContentFragmentVariations: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "List Content Fragment Variations",
+			description: "List the variations of a content fragment."
+		},
+		performSafety: "notAllowed",
+		perform: async (context, params) => {
+			return { data: await fetchCursorPages(createAemClient(params.connection, context.debug.enabled), `${SITES_API_PATH}/cf/fragments/${encodeURIComponent(params.fragmentId)}/variations`, {}, {
+				fetchAll: params.fetchAll,
+				...params.pagination
+			}) };
+		},
+		inputs: listContentFragmentVariationsInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: listContentFragmentVariationsOutputSchema
+		}),
+		examplePerform: async () => listContentFragmentVariationsExamplePayload,
+		examplePayload: listContentFragmentVariationsExamplePayload
+	}),
+	listContentFragments,
+	searchContentFragments: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Search Content Fragments",
+			description: "Search content fragments by path, status, model, tag, locale, modified or published date, and text."
+		},
+		performSafety: "notAllowed",
+		perform: async (context, params) => {
+			const client = createAemClient(params.connection, context.debug.enabled);
+			const query = {
+				filter: {
+					path: params.path,
+					onlyDirectChildren: params.onlyDirectChildren || void 0,
+					status: params.statuses.length ? params.statuses : void 0,
+					modelIds: params.modelIds.length ? params.modelIds : void 0,
+					tags: params.tags.length ? params.tags : void 0,
+					locale: params.locales.length ? params.locales : void 0,
+					modified: toTimeInterval(params.dateRangeFilters?.modifiedAfter, params.dateRangeFilters?.modifiedBefore),
+					published: toTimeInterval(params.dateRangeFilters?.publishedAfter, params.dateRangeFilters?.publishedBefore),
+					fullText: params.filters?.fullText ? { text: params.filters.fullText } : void 0
+				},
+				sort: params.filters?.sortOn ? [{
+					on: params.filters.sortOn,
+					order: params.filters?.sortOrder === "DESC" ? "DESC" : "ASC"
+				}] : void 0
+			};
+			return { data: await fetchCursorPages(client, `${SITES_API_PATH}/cf/fragments/search`, {
+				query: JSON.stringify(query),
+				projection: params.projection,
+				includeMetadata: params.includeMetadata || void 0
+			}, {
+				fetchAll: params.fetchAll,
+				...params.pagination
+			}) };
+		},
+		inputs: searchContentFragmentsInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: searchContentFragmentsOutputSchema
+		}),
+		examplePerform: async () => searchContentFragmentsExamplePayload,
+		examplePayload: searchContentFragmentsExamplePayload
+	})
+};
+//#endregion
+//#region src/actions/folders/index.ts
+var folders_default = {
+	createFolders: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Create Folders",
+			description: "Create one or more asset folders. Fails when no folder could be created; when only some fail, they are listed in failedFolders. A request that runs as a job returns a job ID; check it with Get Folder Job Status."
+		},
+		performSafety: "notAllowed",
+		perform: async (context, { connection, folderPaths }) => {
+			const { data } = await createAemClient(connection, context.debug.enabled).post(`${FOLDERS_API_PATH}/`, folderPaths.map((path) => ({ path })));
+			if (isAemJob(data)) return { data };
+			const values = data.data?.values;
+			return { data: assertFolderCommandProgress(data, values?.successes?.length ?? 0, [...values?.failedFolders ?? [], ...data.errors ?? []]) };
+		},
+		inputs: createFoldersInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: createFoldersOutputSchema
+		}),
+		examplePerform: async () => createFoldersExamplePayload,
+		examplePayload: createFoldersExamplePayload
+	}),
+	deleteFolders: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Delete Folders",
+			description: "Delete one or more asset folders by path. Fails when no folder could be deleted; when only some fail, they are listed in failedFolders. A request that runs as a job returns a job ID; check it with Get Folder Job Status."
+		},
+		performSafety: "notAllowed",
+		perform: async (context, { connection, folderPaths, recursive, force }) => {
+			const { data } = await createAemClient(connection, context.debug.enabled).post(`${FOLDERS_API_PATH}/delete`, {
+				paths: folderPaths,
+				recursive,
+				force
+			});
+			if (isAemJob(data)) return { data };
+			return { data: assertFolderCommandProgress(data, data.data?.deletedFolders?.length ?? 0, [...data.data?.failedFolders ?? [], ...data.errors ?? []]) };
+		},
+		inputs: deleteFoldersInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: deleteFoldersOutputSchema
+		}),
+		examplePerform: async () => deleteFoldersExamplePayload,
+		examplePayload: deleteFoldersExamplePayload
+	}),
+	getFolderJobStatus: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Get Folder Job Status",
+			description: "Retrieve the state of a Create Folders or Delete Folders job."
+		},
+		performSafety: "safe",
+		perform: async (context, { connection, jobId }) => {
+			const { data } = await createAemClient(connection, context.debug.enabled).get(`${FOLDERS_API_PATH}/jobs/${encodeURIComponent(jobId)}/status`);
+			return { data };
+		},
+		inputs: getFolderJobStatusInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: aemJobOutputSchema
+		}),
+		examplePayload: getFolderJobStatusExamplePayload
+	}),
+	listAssetsInFolderTree: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "List Assets in Folder Tree",
+			description: "List every asset in a folder and all of its subfolders."
+		},
+		performSafety: "notAllowed",
+		perform: async (context, { connection, path }) => {
+			const { assets, truncated } = await walkFolderTree(createAemClient(connection, context.debug.enabled), path, { collectAssets: true });
+			if (truncated) throw new Error(`The folder tree under ${path} has more than ${MAX_FOLDER_WALK} folders. Choose a narrower folder path.`);
+			return { data: assets };
+		},
+		inputs: listAssetsInFolderTreeInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: listAssetsInFolderTreeOutputSchema
+		}),
+		examplePerform: async () => listAssetsInFolderTreeExamplePayload,
+		examplePayload: listAssetsInFolderTreeExamplePayload
+	}),
+	listFolderContents: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "List Folder Contents",
+			description: "List the folders and assets directly inside a folder."
+		},
+		performSafety: "notAllowed",
+		perform: async (context, { connection, path, fetchAll, pagination, types, orderBy }) => {
+			const client = createAemClient(connection, context.debug.enabled);
+			const url = `${FOLDERS_API_PATH}/`;
+			if (!fetchAll) {
+				const { data } = await client.get(url, { params: {
+					path,
+					types,
+					orderBy,
+					cursor: pagination?.cursor,
+					limit: pagination?.limit
+				} });
+				return { data };
+			}
+			const children = [];
+			let self;
+			let next = pagination?.cursor;
+			do {
+				const { data } = await client.get(url, { params: {
+					path,
+					types,
+					orderBy,
+					cursor: next,
+					limit: 50
+				} });
+				self = self ?? data.self;
+				children.push(...data.children ?? []);
+				next = data.cursor;
+			} while (next);
+			return { data: {
+				self,
+				children
+			} };
+		},
+		inputs: listFolderContentsInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: listFolderContentsOutputSchema
+		}),
+		examplePerform: async () => listFolderContentsExamplePayload,
+		examplePayload: listFolderContentsExamplePayload
+	})
+};
+//#endregion
+//#region src/actions/misc/index.ts
+var misc_default = { rawRequest: (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Raw Request",
+		description: "Send raw HTTP request to Adobe Experience Manager."
+	},
+	performSafety: "notAllowed",
+	inputs: rawRequestInputs,
+	perform: async ({ debug: { enabled: debug } }, { connection, ...params }) => {
+		const client = createAemClient(connection, debug);
+		const { data } = await (0, _prismatic_io_spectral_http.sendRawRequest)(getAemBaseUrl(connection), {
+			...params,
+			debugRequest: debug
+		}, client.defaults?.headers ?? {});
+		return { data };
+	},
+	examplePayload: rawRequestExamplePayload
+}) };
+//#endregion
+//#region src/pageSources/sitemapPageSource.ts
+const headerOrNull = (headers, name) => {
+	const value = headers[name];
+	return typeof value === "string" ? value : null;
+};
+const createSitemapPageSource = (client) => ({
+	async listPages(params) {
+		const rootHost = new URL(params.sitemapUrl).host;
+		const queue = [params.sitemapUrl];
+		const visited = /* @__PURE__ */ new Set();
+		const pages = [];
+		while (queue.length && visited.size < 50) {
+			const url = queue.shift();
+			if (visited.has(url)) continue;
+			visited.add(url);
+			const { data } = await client.get(url);
+			const parsed = parseSitemap(_prismatic_io_spectral.util.types.toString(data));
+			queue.push(...parsed.sitemaps.filter((child) => {
+				try {
+					const childUrl = new URL(child);
+					return childUrl.protocol === "https:" && childUrl.host === rootHost;
+				} catch {
+					return false;
+				}
+			}));
+			pages.push(...parsed.pages);
+		}
+		return filterPages(pages, params);
+	},
+	async getPageContent(url) {
+		const response = await client.get(url);
+		const headers = response.headers;
+		return {
+			url,
+			finalUrl: response.request?.res?.responseUrl ?? url,
+			statusCode: response.status,
+			contentType: headerOrNull(headers, "content-type"),
+			lastModified: headerOrNull(headers, "last-modified"),
+			etag: headerOrNull(headers, "etag"),
+			html: _prismatic_io_spectral.util.types.toString(response.data)
+		};
+	}
+});
+//#endregion
+//#region src/actions/pages/index.ts
+var pages_default = {
+	getPublishedPageHtml: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Get Published Page HTML",
+			description: "Retrieve the published HTML of a page by URL. Accepts URLs from List Sitemap URLs or AEM Sites Event Subscription page events."
+		},
+		performSafety: "notAllowed",
+		perform: async (context, { pageUrl }) => {
+			return { data: await createSitemapPageSource(createPublicClient(context.debug.enabled)).getPageContent(pageUrl) };
+		},
+		inputs: getPublishedPageHtmlInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: getPublishedPageHtmlOutputSchema
+		}),
+		examplePerform: async () => getPublishedPageHtmlExamplePayload,
+		examplePayload: getPublishedPageHtmlExamplePayload
+	}),
+	listSitemapUrls: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "List Sitemap URLs",
+			description: "List page URLs and their last-modified dates from a site's sitemap, following a sitemap index. Pass the URLs to Get Published Page HTML."
+		},
+		performSafety: "notAllowed",
+		perform: async (context, { sitemapUrl, modifiedAfter, includePathPrefixes, excludePathPrefixes }) => {
+			return { data: await createSitemapPageSource(createPublicClient(context.debug.enabled)).listPages({
+				sitemapUrl,
+				modifiedAfter,
+				includePathPrefixes,
+				excludePathPrefixes
+			}) };
+		},
+		inputs: listSitemapUrlsInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: listSitemapUrlsOutputSchema
+		}),
+		examplePerform: async () => listSitemapUrlsExamplePayload,
+		examplePayload: listSitemapUrlsExamplePayload
+	})
+};
+//#endregion
+//#region src/actions/index.ts
+var actions_default = {
+	...contentFragments_default,
+	...folders_default,
+	...assets_default,
+	...pages_default,
+	...misc_default
+};
+//#endregion
+//#region src/dataSources/index.ts
+var dataSources_default = {
+	selectAsset: (0, _prismatic_io_spectral.dataSource)({
+		display: {
+			label: "Select Asset",
+			description: "Select an asset from the list of assets."
+		},
+		inputs: selectAssetInputs,
+		examplePayload: selectAssetExamplePayload,
+		perform: async (_context, { connection }) => {
+			const client = createAemClient(connection, false);
+			const query = [{ match: { text: "" } }];
+			const hits = [];
+			let cursor;
+			do {
+				const { data } = await client.post(`${ASSETS_API_PATH}/search`, {
+					query,
+					limit: 50,
+					cursor
+				});
+				hits.push(...data.hits?.results ?? []);
+				cursor = data.cursor;
+			} while (cursor && hits.length < 1e3);
+			return { result: hits.slice(0, MAX_DATA_SOURCE_ITEMS).map((hit) => ({
+				label: hit.repositoryMetadata?.["repo:path"] ?? hit.repositoryMetadata?.["repo:name"] ?? hit.assetId,
+				key: hit.assetId
+			})).sort(compareElementLabels) };
+		},
+		dataSourceType: "picklist"
+	}),
+	selectAssetRendition: (0, _prismatic_io_spectral.dataSource)({
+		display: {
+			label: "Select Asset Rendition",
+			description: "Select a rendition from the renditions available for an asset."
+		},
+		inputs: selectAssetRenditionInputs,
+		examplePayload: selectAssetRenditionExamplePayload,
+		perform: async (_context, { connection, assetId }) => {
+			const { data } = await createAemClient(connection, false).get(`${ASSETS_API_PATH}/${encodeURIComponent(assetId)}/renditions`);
+			return { result: (data.items ?? []).map((rendition) => ({
+				label: rendition.name,
+				key: rendition.name
+			})).sort(compareElementLabels) };
+		},
+		dataSourceType: "picklist"
+	}),
+	selectContentFragment: (0, _prismatic_io_spectral.dataSource)({
+		display: {
+			label: "Select Content Fragment",
+			description: "Select a content fragment from the list of content fragments."
+		},
+		inputs: selectContentFragmentInputs,
+		examplePayload: selectContentFragmentExamplePayload,
+		perform: async (_context, { connection, path }) => {
+			const client = createAemClient(connection, false);
+			const fragments = [];
+			let cursor;
+			do {
+				const page = await fetchCursorPages(client, `${SITES_API_PATH}/cf/fragments`, { path }, {
+					fetchAll: false,
+					cursor,
+					limit: 50
+				});
+				fragments.push(...page.items);
+				cursor = page.cursor;
+			} while (cursor && fragments.length < 1e3);
+			return { result: fragments.slice(0, MAX_DATA_SOURCE_ITEMS).map((fragment) => ({
+				label: fragment.title ? `${fragment.title} (${fragment.path})` : fragment.path,
+				key: fragment.id
+			})).sort(compareElementLabels) };
+		},
+		dataSourceType: "picklist"
+	}),
+	selectContentFragmentModel: (0, _prismatic_io_spectral.dataSource)({
+		display: {
+			label: "Select Content Fragment Model",
+			description: "Select a content fragment model from the list of models."
+		},
+		inputs: selectContentFragmentModelInputs,
+		examplePayload: selectContentFragmentModelExamplePayload,
+		perform: async (_context, { connection }) => {
+			const { items } = await fetchCursorPages(createAemClient(connection, false), `${SITES_API_PATH}/cf/models`, {}, { fetchAll: true });
+			return { result: items.map((model) => ({
+				label: model.title ?? model.name,
+				key: model.id
+			})).sort(compareElementLabels) };
+		},
+		dataSourceType: "picklist"
+	}),
+	selectFolder: (0, _prismatic_io_spectral.dataSource)({
+		display: {
+			label: "Select Folder",
+			description: "Select an asset folder from the folders under /content/dam."
+		},
+		inputs: selectFolderInputs,
+		examplePayload: selectFolderExamplePayload,
+		perform: async (_context, { connection }) => {
+			const { folders } = await walkFolderTree(createAemClient(connection, false), DEFAULT_DAM_ROOT, { collectAssets: false });
+			return { result: folders.filter((folder) => folder.folderId).map((folder) => ({
+				label: folder.path ?? folder.name ?? _prismatic_io_spectral.util.types.toString(folder.folderId),
+				key: _prismatic_io_spectral.util.types.toString(folder.folderId)
+			})).sort(compareElementLabels) };
+		},
+		dataSourceType: "picklist"
+	}),
+	selectFolderPath: (0, _prismatic_io_spectral.dataSource)({
+		display: {
+			label: "Select Folder Path",
+			description: "Select an asset folder path from /content/dam and the folders under it."
+		},
+		inputs: selectFolderPathInputs,
+		examplePayload: selectFolderPathExamplePayload,
+		perform: async (_context, { connection }) => {
+			const { folders } = await walkFolderTree(createAemClient(connection, false), DEFAULT_DAM_ROOT, { collectAssets: false });
+			const paths = /* @__PURE__ */ new Set([DEFAULT_DAM_ROOT]);
+			for (const folder of folders) if (folder.path) paths.add(folder.path);
+			return { result: [...paths].map((path) => ({
+				label: path,
+				key: path
+			})).sort(compareElementLabels) };
+		},
+		dataSourceType: "picklist"
+	}),
+	selectSitemapPage: (0, _prismatic_io_spectral.dataSource)({
+		display: {
+			label: "Select Sitemap Page",
+			description: "Select a published page URL from a site's sitemap."
+		},
+		inputs: selectSitemapPageInputs,
+		examplePayload: selectSitemapPageExamplePayload,
+		perform: async (_context, { sitemapUrl }) => {
+			return { result: (await createSitemapPageSource(createPublicClient(false)).listPages({ sitemapUrl })).slice(0, MAX_DATA_SOURCE_ITEMS).map((page) => ({
+				label: page.loc,
+				key: page.loc
+			})).sort(compareElementLabels) };
+		},
+		dataSourceType: "picklist"
+	})
+};
+//#endregion
+//#region src/triggers/aemAssetsEventWebhook.ts
+const LABEL$1 = "AEM Assets Event Subscription";
+const aemAssetsEventWebhook = (0, _prismatic_io_spectral.trigger)({
+	display: {
+		label: LABEL$1,
+		description: "Receive and validate asset events from Adobe Experience Manager, including metadata updates that the New and Updated Assets trigger cannot detect. Handles URL verification challenges automatically, and automatically creates and manages an Adobe I/O Events webhook registration with the environment's AEM Assets event provider when the instance is deployed, removing it when the instance is deleted."
+	},
+	inputs: aemAssetsEventWebhookInputs,
+	scheduleSupport: "invalid",
+	synchronousResponseSupport: "valid",
+	allowsBranching: true,
+	staticBranchNames: AEM_EVENT_BRANCHES,
+	webhookLifecycleHandlers: aemEventLifecycleHandlers(LABEL$1),
+	perform: performAemEvent,
+	examplePayload: aemAssetsEventWebhookExamplePayload
+});
+//#endregion
+//#region src/triggers/aemSitesEventWebhook.ts
+const LABEL = "AEM Sites Event Subscription";
+const aemSitesEventWebhook = (0, _prismatic_io_spectral.trigger)({
+	display: {
+		label: LABEL,
+		description: "Receive and validate content fragment and page events from Adobe Experience Manager. Handles URL verification challenges automatically, and automatically creates and manages an Adobe I/O Events webhook registration with the environment's AEM Sites event provider when the instance is deployed, removing it when the instance is deleted. With a Publish Base URL, page events carry the published page URL for Get Published Page HTML."
+	},
+	inputs: aemSitesEventWebhookInputs,
+	scheduleSupport: "invalid",
+	synchronousResponseSupport: "valid",
+	allowsBranching: true,
+	staticBranchNames: AEM_EVENT_BRANCHES,
+	webhookLifecycleHandlers: aemEventLifecycleHandlers(LABEL),
+	perform: performAemEvent,
+	examplePayload: aemSitesEventWebhookExamplePayload
+});
+//#endregion
+//#region src/triggers/assetChanges.ts
+const assetChanges = (0, _prismatic_io_spectral.pollingTrigger)({
+	display: {
+		label: "New and Updated Assets",
+		description: "Retrieves existing and ongoing assets from Adobe Experience Manager. Load history once, check for changes on a schedule, or both."
+	},
+	inputs: assetChangesInputs,
+	triggerResolverSupport: "valid",
+	batchConfig: { batchSize: 50 },
+	triggerResolver: {
+		resolveItems: (_context, { payload }) => resolveAemChangeItems(payload.body.data),
+		getNextPaginationState: (_context, { payload }) => payload.paginationState ?? null
+	},
+	perform: async (context, payload, params) => {
+		const isBatching = context.batch?.enabled === true;
+		const incoming = payload.paginationState;
+		const state = context.polling.getState() ?? {};
+		const window = resolvePollWindow(state, incoming, params.lookBackDate, windowNow());
+		const windowIsEmpty = window.windowStart >= window.windowEnd;
+		const client = createAemClient(params.connection, context.debug.enabled);
+		const { records, cursor } = windowIsEmpty ? {
+			records: [],
+			cursor: void 0
+		} : await listChangedAssets(client, params, window, isBatching);
+		const nextCursor = cursor ? {
+			windowStart: window.windowStart,
+			windowEnd: window.windowEnd,
+			cursor
+		} : void 0;
+		context.polling.setState(nextPollingState(state, window, nextCursor));
+		const scope = params.folderIds.length ? params.folderIds.join(",") : DEFAULT_DAM_ROOT;
+		const items = records.map((hit) => {
+			const record = toAssetRecord(hit, scope, params.publishBaseUrl);
+			return {
+				changeType: classifyChange(record, window.windowStart, window.isInitialSync),
+				record
+			};
+		});
+		if (context.debug.enabled) context.logger.debug(`Assets ${window.windowStart} to ${window.windowEnd}: ${items.length} changed; ${nextCursor ? "more pages remain" : "window drained"}`);
+		return {
+			payload: {
+				...payload,
+				paginationState: nextCursor,
+				body: { data: { items } }
+			},
+			polledNoChanges: items.length === 0 && !nextCursor && !incoming
+		};
+	},
+	examplePayload: assetChangesExamplePayload
+});
+//#endregion
+//#region src/triggers/index.ts
+var triggers_default = {
+	contentFragmentChanges: (0, _prismatic_io_spectral.pollingTrigger)({
+		display: {
+			label: "New and Updated Fragments",
+			description: "Retrieves existing and ongoing content fragments from Adobe Experience Manager. Load history once, check for changes on a schedule, or both."
+		},
+		inputs: contentFragmentChangesInputs,
+		triggerResolverSupport: "valid",
+		batchConfig: { batchSize: 50 },
+		triggerResolver: {
+			resolveItems: (_context, { payload }) => resolveAemChangeItems(payload.body.data),
+			getNextPaginationState: (_context, { payload }) => payload.paginationState ?? null
+		},
+		perform: async (context, payload, params) => {
+			const isBatching = context.batch?.enabled === true;
+			const incoming = payload.paginationState;
+			const state = context.polling.getState() ?? {};
+			const window = resolvePollWindow(state, incoming, params.lookBackDate, windowNow());
+			const windowIsEmpty = window.windowStart >= window.windowEnd;
+			const client = createAemClient(params.connection, context.debug.enabled);
+			const { records, cursor } = windowIsEmpty ? {
+				records: [],
+				cursor: void 0
+			} : await listChangedContentFragments(client, buildContentFragmentTriggerFilter(params), window, isBatching);
+			const nextCursor = cursor ? {
+				windowStart: window.windowStart,
+				windowEnd: window.windowEnd,
+				cursor
+			} : void 0;
+			context.polling.setState(nextPollingState(state, window, nextCursor));
+			const scope = params.path ?? "/content/dam";
+			const items = records.map((fragment) => {
+				const record = toContentFragmentRecord(fragment, scope, params.publishBaseUrl);
+				return {
+					changeType: classifyChange(record, window.windowStart, window.isInitialSync),
+					record
+				};
+			});
+			if (context.debug.enabled) context.logger.debug(`Content fragments ${window.windowStart} to ${window.windowEnd}: ${items.length} changed; ${nextCursor ? "more pages remain" : "window drained"}`);
+			return {
+				payload: {
+					...payload,
+					paginationState: nextCursor,
+					body: { data: { items } }
+				},
+				polledNoChanges: items.length === 0 && !nextCursor && !incoming
+			};
+		},
+		examplePayload: contentFragmentChangesExamplePayload
+	}),
+	assetChanges,
+	aemSitesEventWebhook,
+	aemAssetsEventWebhook
+};
+//#endregion
+//#region src/index.ts
+var src_default = (0, _prismatic_io_spectral.component)({
+	key: "adobe-experience-manager",
+	public: true,
+	documentationUrl: "https://prismatic.io/docs/components/adobe-experience-manager/",
+	display: {
+		label: "Adobe Experience Manager",
+		description: "Read content fragments, assets, and published pages from Adobe Experience Manager as a Cloud Service, and detect content changes.",
+		iconPath: "icon.png",
+		category: "Application Connectors"
+	},
+	connections: connections_default,
+	actions: actions_default,
+	dataSources: dataSources_default,
+	triggers: triggers_default,
+	hooks: { error: _prismatic_io_spectral_http.handleErrors }
+});
+//#endregion
+//#region npm-dist/.entry.ts
+var _entry_default = (0, _prismatic_io_spectral.callableComponent)(src_default);
+//#endregion
+module.exports = _entry_default;