@prismatic-io/components-jamf 0.0.0-stage → 0.0.1

package/npm-dist/index.cjs

@@ -0,0 +1,2885 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+let _prismatic_io_spectral = require("@prismatic-io/spectral");
+let _prismatic_io_spectral_http = require("@prismatic-io/spectral/http");
+let node_crypto = require("node:crypto");
+//#region src/connections/jamfBearerToken.ts
+const jamfBearerToken = (0, _prismatic_io_spectral.connection)({
+	key: "jamfBearerToken",
+	display: {
+		label: "Basic Authentication",
+		description: "Authenticate using username and password."
+	},
+	inputs: {
+		baseUrl: (0, _prismatic_io_spectral.input)({
+			label: "Jamf Pro URL",
+			type: "string",
+			required: true,
+			shown: true,
+			comments: "The base URL of the Jamf Pro instance (e.g., https://acme.jamfcloud.com).",
+			placeholder: "Enter Jamf Pro URL (e.g., https://acme.jamfcloud.com)",
+			example: "https://acme.jamfcloud.com"
+		}),
+		username: (0, _prismatic_io_spectral.input)({
+			label: "Username",
+			type: "string",
+			required: true,
+			shown: true,
+			comments: "The Jamf Pro user account username. SSO accounts cannot be used for API authentication.",
+			placeholder: "Enter Jamf Pro username",
+			example: "admin"
+		}),
+		password: (0, _prismatic_io_spectral.input)({
+			label: "Password",
+			type: "password",
+			required: true,
+			shown: true,
+			comments: "The Jamf Pro user account password."
+		})
+	}
+});
+//#endregion
+//#region src/connections/jamfClientCredentials.ts
+const jamfClientCredentials = (0, _prismatic_io_spectral.connection)({
+	key: "jamfClientCredentials",
+	display: {
+		label: "OAuth 2.0 Client Credentials",
+		description: "Authenticate using OAuth 2.0 client credentials."
+	},
+	inputs: {
+		baseUrl: (0, _prismatic_io_spectral.input)({
+			label: "Jamf Pro URL",
+			type: "string",
+			required: true,
+			shown: true,
+			comments: "The base URL of the Jamf Pro instance (e.g., https://acme.jamfcloud.com).",
+			placeholder: "Enter Jamf Pro URL (e.g., https://acme.jamfcloud.com)",
+			example: "https://acme.jamfcloud.com"
+		}),
+		clientId: (0, _prismatic_io_spectral.input)({
+			label: "Client ID",
+			type: "string",
+			required: true,
+			shown: true,
+			comments: "The API Client ID from Settings > API Roles and Clients in Jamf Pro.",
+			placeholder: "Enter API Client ID",
+			example: "abc12345-1234-1234-1234-abc1234567890"
+		}),
+		clientSecret: (0, _prismatic_io_spectral.input)({
+			label: "Client Secret",
+			type: "password",
+			required: true,
+			shown: true,
+			comments: "The API Client Secret from Settings > API Roles and Clients in Jamf Pro."
+		})
+	}
+});
+//#endregion
+//#region src/connections/index.ts
+var connections_default = [jamfClientCredentials, jamfBearerToken];
+//#endregion
+//#region src/client.ts
+const fetchAccessToken = async (connection, baseUrl) => {
+	if (connection.key === jamfClientCredentials.key) {
+		const clientId = _prismatic_io_spectral.util.types.toString(connection.fields.clientId);
+		const clientSecret = _prismatic_io_spectral.util.types.toString(connection.fields.clientSecret);
+		return (await (0, _prismatic_io_spectral_http.createClient)({ baseUrl }).post("/api/v1/oauth/token", new URLSearchParams({
+			grant_type: "client_credentials",
+			client_id: clientId,
+			client_secret: clientSecret
+		}).toString(), { headers: { "Content-Type": "application/x-www-form-urlencoded" } })).data.access_token;
+	}
+	if (connection.key === jamfBearerToken.key) {
+		const username = _prismatic_io_spectral.util.types.toString(connection.fields.username);
+		const password = _prismatic_io_spectral.util.types.toString(connection.fields.password);
+		return (await (0, _prismatic_io_spectral_http.createClient)({
+			baseUrl,
+			headers: { Authorization: `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}` }
+		}).post("/api/v1/auth/token")).data.token;
+	}
+	throw new _prismatic_io_spectral.ConnectionError(connection, `Unsupported connection type: ${connection.key}`);
+};
+const getBaseUrl = (connection) => _prismatic_io_spectral.util.types.toString(connection.fields.baseUrl).replace(/\/$/, "");
+const createClient = async (connection, debug = false) => {
+	const baseUrl = getBaseUrl(connection);
+	const token = await fetchAccessToken(connection, baseUrl);
+	return (0, _prismatic_io_spectral_http.createClient)({
+		baseUrl: `${baseUrl}/api`,
+		headers: {
+			Authorization: `Bearer ${token}`,
+			"Content-Type": "application/json",
+			Accept: "application/json"
+		},
+		debug
+	});
+};
+const createClassicClient = async (connection, debug = false) => {
+	const baseUrl = getBaseUrl(connection);
+	const token = await fetchAccessToken(connection, baseUrl);
+	return (0, _prismatic_io_spectral_http.createClient)({
+		baseUrl: `${baseUrl}/JSSResource`,
+		headers: {
+			Authorization: `Bearer ${token}`,
+			Accept: "application/json"
+		},
+		debug
+	});
+};
+//#endregion
+//#region src/examplePayloads/categories.ts
+const getCategoryExamplePayload = { data: {
+	id: "7",
+	name: "Productivity Apps",
+	priority: 9
+} };
+const listCategoriesExamplePayload = { data: {
+	results: [getCategoryExamplePayload.data],
+	totalCount: 1
+} };
+const createCategoryExamplePayload = { data: {
+	id: "8",
+	href: "https://your-instance.jamfcloud.com/api/v1/categories/8"
+} };
+const updateCategoryExamplePayload = { data: {
+	id: "7",
+	name: "Productivity Apps",
+	priority: 9
+} };
+const deleteCategoryExamplePayload = { data: "Successfully deleted category 7" };
+const selectCategoryExamplePayload = { result: [{
+	key: "7",
+	label: "Productivity Apps"
+}] };
+//#endregion
+//#region src/examplePayloads/computers.ts
+const getComputerExamplePayload = { data: {
+	id: "1",
+	udid: "A8C5F29D-1234-5678-ABCD-9E0F1B2C3D4E",
+	general: {
+		name: "MacBook-Pro-001",
+		lastContactTime: "2026-04-15T10:23:00.000Z",
+		platform: "Mac",
+		assetTag: null,
+		reportDate: "2026-04-15T10:22:00.000Z",
+		remoteManagement: { managed: true },
+		supervised: true
+	},
+	hardware: {
+		make: "Apple",
+		model: "MacBook Pro (16-inch, 2023)",
+		serialNumber: "C02XY1234567",
+		processorType: "Apple M2 Pro",
+		totalRamMegabytes: 16384
+	},
+	operatingSystem: {
+		name: "macOS",
+		version: "15.4.0",
+		build: "24E248"
+	},
+	userAndLocation: {
+		username: "jdoe",
+		realname: "Jane Doe",
+		email: "jdoe@example.com",
+		department: "Engineering",
+		building: null
+	},
+	security: {
+		sipStatus: "ENABLED",
+		gatekeeperStatus: "APP_STORE_AND_IDENTIFIED_DEVELOPERS",
+		xprotectVersion: "2199",
+		firewall: true
+	}
+} };
+const listComputersExamplePayload = { data: {
+	results: [getComputerExamplePayload.data],
+	totalCount: 1
+} };
+const updateComputerExamplePayload = { data: "Successfully updated computer 1" };
+const selectComputerExamplePayload = { result: [{
+	key: "1",
+	label: "MacBook-Pro-001"
+}] };
+//#endregion
+//#region src/examplePayloads/departments.ts
+const getDepartmentExamplePayload = { data: {
+	id: "10",
+	name: "Information Technology"
+} };
+const listDepartmentsExamplePayload = { data: {
+	results: [getDepartmentExamplePayload.data],
+	totalCount: 1
+} };
+const createDepartmentExamplePayload = { data: {
+	id: "11",
+	href: "https://your-instance.jamfcloud.com/api/v1/departments/11"
+} };
+const updateDepartmentExamplePayload = { data: {
+	id: "10",
+	name: "Information Technology"
+} };
+const deleteDepartmentExamplePayload = { data: "Successfully deleted department 10" };
+const selectDepartmentExamplePayload = { result: [{
+	key: "10",
+	label: "Information Technology"
+}] };
+const getMobileDeviceExamplePayload = { data: {
+	id: "5",
+	managementId: "mgmt-abc-123",
+	name: "iPad-001",
+	udid: "B3D6E19F-4321-8765-DCBA-EF0A1B2C3D4E",
+	serialNumber: "DMPC123456789",
+	wifiMacAddress: "a4:5e:60:ab:cd:ef",
+	phoneNumber: null,
+	username: "jdoe",
+	type: "ios",
+	model: "iPad Pro (11-inch) (4th generation)",
+	modelIdentifier: "iPad14,3",
+	softwareUpdateDeviceId: null,
+	osVersion: "17.4",
+	osType: "iOS",
+	realname: "Jane Doe",
+	email: "jdoe@example.com",
+	department: "Engineering"
+} };
+const listMobileDevicesExamplePayload = { data: {
+	results: [{
+		mobileDeviceId: "5",
+		deviceType: "iOS",
+		general: {
+			udid: "B3D6E19F-4321-8765-DCBA-EF0A1B2C3D4E",
+			displayName: "iPad-001",
+			assetTag: "304822",
+			siteId: "1",
+			lastInventoryUpdateDate: "2026-06-14T18:22:05.000Z",
+			osVersion: "17.4",
+			osRapidSecurityResponse: "(a)",
+			osBuild: "21E219",
+			osSupplementalBuildVersion: "21E220",
+			softwareUpdateDeviceId: "J617AP",
+			ipAddress: "10.0.12.45",
+			managed: true,
+			supervised: true,
+			deviceOwnershipType: "Institutional",
+			enrollmentMethodPrestage: "PreStage enrollment",
+			enrollmentSessionTokenValid: true,
+			lastEnrolledDate: "2026-01-05T09:14:00.000Z",
+			mdmProfileExpirationDate: "2027-01-05T09:14:00.000Z",
+			timeZone: "America/Chicago",
+			declarativeDeviceManagementEnabled: true,
+			managementId: "mgmt-abc-123",
+			extensionAttributes: [],
+			lastLoggedInUsernameSelfService: null,
+			lastLoggedInUsernameSelfServiceTimestamp: null,
+			sharedIpad: false,
+			diagnosticAndUsageReportingEnabled: false,
+			appAnalyticsEnabled: false,
+			residentUsers: null,
+			quotaSize: null,
+			temporarySessionOnly: null,
+			temporarySessionTimeout: null,
+			userSessionTimeout: null,
+			syncedToComputer: -1,
+			maximumSharediPadUsersStored: -1,
+			lastBackupDate: "2026-06-10T03:00:00.000Z",
+			deviceLocatorServiceEnabled: false,
+			doNotDisturbEnabled: false,
+			cloudBackupEnabled: true,
+			lastCloudBackupDate: "2026-06-13T03:11:00.000Z",
+			locationServicesForSelfServiceMobileEnabled: false,
+			itunesStoreAccountActive: false,
+			exchangeDeviceId: "",
+			tethered: false
+		},
+		hardware: {
+			capacityMb: 256e3,
+			availableSpaceMb: 198450,
+			usedSpacePercentage: 22,
+			batteryLevel: 87,
+			serialNumber: "DMPC123456789",
+			wifiMacAddress: "a4:5e:60:ab:cd:ef",
+			bluetoothMacAddress: "a4:5e:60:ab:cd:f0",
+			modelIdentifier: "iPad14,3",
+			model: "iPad Pro (11-inch) (4th generation)",
+			modelNumber: "MNXE3LL/A",
+			bluetoothLowEnergyCapable: true,
+			deviceId: "J617AP"
+		},
+		userAndLocation: {
+			username: "jdoe",
+			realName: "Jane Doe",
+			emailAddress: "jdoe@example.com",
+			position: "Field Technician",
+			phoneNumber: "555-0142",
+			departmentId: "1",
+			buildingId: "1",
+			room: "204",
+			building: "Headquarters",
+			department: "Engineering"
+		},
+		security: {
+			dataProtected: true,
+			blockLevelEncryptionCapable: true,
+			fileLevelEncryptionCapable: true,
+			passcodePresent: true,
+			passcodeCompliant: true,
+			passcodeCompliantWithProfile: true,
+			hardwareEncryption: 3,
+			activationLockEnabled: true,
+			jailBreakDetected: false,
+			lostModeEnabled: false
+		}
+	}],
+	totalCount: 1
+} };
+const selectMobileDeviceExamplePayload = { result: [{
+	key: "5",
+	label: "iPad-001"
+}] };
+//#endregion
+//#region src/examplePayloads/packages.ts
+const packageExample = {
+	id: "20",
+	packageName: "Google Chrome 120.0",
+	fileName: "GoogleChrome-120.0.6099.199.pkg",
+	categoryId: "-1",
+	info: "Google Chrome browser installer.",
+	notes: "",
+	priority: 10,
+	osRequirements: "",
+	rebootRequired: false,
+	fillUserTemplate: false,
+	indexed: false,
+	fillExistingUsers: false,
+	swu: false,
+	selfHealNotify: false,
+	selfHealingAction: "nothing",
+	osInstall: false,
+	serialNumber: "",
+	parentPackageId: "-1",
+	basePath: "",
+	suppressUpdates: false,
+	cloudTransferStatus: "",
+	ignoreConflicts: false,
+	suppressFromDock: false,
+	suppressEula: false,
+	suppressRegistration: false,
+	installLanguage: "en_US",
+	md5: "",
+	sha256: "",
+	hashType: "SHA_512",
+	hashValue: "",
+	size: "",
+	osInstallerVersion: "",
+	manifest: "",
+	manifestFileName: "",
+	format: "",
+	sha3512: ""
+};
+const getPackageExamplePayload = { data: packageExample };
+const listPackagesExamplePayload = { data: {
+	results: [packageExample],
+	totalCount: 1
+} };
+const createPackageExamplePayload = { data: {
+	id: "21",
+	href: "https://your-instance.jamfcloud.com/api/v1/packages/21"
+} };
+const updatePackageExamplePayload = { data: packageExample };
+const deletePackageExamplePayload = { data: "Successfully deleted package 20" };
+const selectPackageExamplePayload = { result: [{
+	key: "12",
+	label: "Google Chrome 120.0.pkg"
+}] };
+//#endregion
+//#region src/examplePayloads/scripts.ts
+const scriptExample = {
+	id: "12",
+	name: "Install Chrome",
+	categoryId: "3",
+	categoryName: "Browsers",
+	info: "Installs Google Chrome from the vendor CDN.",
+	notes: "",
+	priority: "AFTER",
+	parameter4: "",
+	parameter5: "",
+	parameter6: "",
+	parameter7: "",
+	parameter8: "",
+	parameter9: "",
+	parameter10: "",
+	parameter11: "",
+	osRequirements: "",
+	scriptContents: "#!/bin/bash\necho 'Installing Chrome'"
+};
+const getScriptExamplePayload = { data: scriptExample };
+const listScriptsExamplePayload = { data: {
+	results: [scriptExample],
+	totalCount: 1
+} };
+const createScriptExamplePayload = { data: {
+	id: "13",
+	href: "https://your-instance.jamfcloud.com/api/v1/scripts/13"
+} };
+const updateScriptExamplePayload = { data: scriptExample };
+const deleteScriptExamplePayload = { data: "Successfully deleted script 12" };
+const selectScriptExamplePayload = { result: [{
+	key: "7",
+	label: "Install Chrome"
+}] };
+//#endregion
+//#region src/examplePayloads/users.ts
+const listUsersExamplePayload = { data: {
+	results: [{
+		id: "42",
+		username: "jdoe",
+		realname: "Jane Doe",
+		email: "jdoe@example.com",
+		position: "Software Engineer",
+		enableCustomPhotoUrl: false,
+		customPhotoUrl: null,
+		ldapServer: null,
+		extensionAttributes: []
+	}],
+	totalCount: 1,
+	page: 0,
+	pageSize: 100,
+	totalPages: 1,
+	hasNext: false,
+	hasPrevious: false
+} };
+//#endregion
+//#region src/examplePayloads/webhook.ts
+const webhookExamplePayload = { payload: {
+	headers: {
+		Accept: "text/plain, application/xml, text/xml, application/json, application/cbor, application/*+xml, application/*+json, */*",
+		"Content-Type": "application/json",
+		Host: "hooks.example.com",
+		"User-Agent": "Java/21.0.11",
+		"X-Jamf-Signature": "123456"
+	},
+	queryParameters: {},
+	rawBody: { data: "" },
+	body: {
+		data: {
+			webhook: {
+				id: 9,
+				name: "Header Auth",
+				webhookEvent: "ComputerAdded",
+				eventTimestamp: 1780529995879
+			},
+			event: {
+				udid: "45436edf-864e-4364-982a-330b01d39e28",
+				deviceName: "Boalime",
+				model: "13-inch MacBook Pro (Mid 2012)",
+				macAddress: "6A:2C:4B:B7:65:C8",
+				alternateMacAddress: "82:45:58:44:dc:07",
+				serialNumber: "C02ZC2QYLJHD",
+				osVersion: "10.9.5",
+				osBuild: "13A603",
+				userDirectoryID: "-1",
+				username: "Madison Anderson",
+				realName: "13-inch MacBook",
+				emailAddress: "email@com.pl",
+				phone: "123-456-789",
+				position: "IT Team Lead",
+				department: "",
+				building: "",
+				room: "5",
+				ipAddress: "247.185.82.186",
+				reportedIpV4Address: "247.185.82.186",
+				reportedIpV6Address: "",
+				jssID: 6,
+				managementId: "fd14f8f3-d5a4-4c44-ad7b-5f93d2ed15cb"
+			}
+		},
+		contentType: "application/json"
+	},
+	pathFragment: "",
+	webhookUrls: { Webhook: "https://hooks.example.com/trigger/abc123==" },
+	webhookApiKeys: { Webhook: ["sample-api-key"] },
+	invokeUrl: "https://hooks.example.com/trigger/abc123==",
+	executionId: "exec_789456",
+	customer: {
+		id: "cust_12345",
+		name: "Example Customer",
+		externalId: "ext_cust_98765"
+	},
+	instance: {
+		id: "inst_54321",
+		name: "Jamf - Webhook Integration"
+	},
+	user: {
+		id: "user_67890",
+		email: "admin@example.com",
+		name: "Admin User",
+		externalId: "ext_user_12345"
+	},
+	integration: {
+		id: "intg_98765",
+		name: "Jamf - Webhook Integration",
+		versionSequenceId: "v1.0.0",
+		externalVersion: "1.0.0"
+	},
+	flow: {
+		id: "flow_45678",
+		name: "Computer Inventory Completed Webhook",
+		stableId: "stable_flow_45678"
+	},
+	startedAt: "2026-04-15T10:23:00.000Z",
+	globalDebug: false
+} };
+const getWebhookExamplePayload = { data: { webhook: {
+	id: 1,
+	name: "New Computer Notifier",
+	enabled: true,
+	url: "https://example.com/webhook",
+	content_type: "application/json",
+	event: "ComputerAdded",
+	connection_timeout: 5,
+	read_timeout: 2,
+	authentication_type: "NONE"
+} } };
+const createWebhookExamplePayload = { data: { id: 1 } };
+const updateWebhookExamplePayload = { data: { id: 1 } };
+const listWebhooksExamplePayload = { data: { webhooks: [{
+	id: 1,
+	name: "New Computer Notifier"
+}] } };
+const deleteWebhookExamplePayload = { data: "Successfully deleted webhook 1" };
+const deleteInstancedWebhooksExamplePayload = { data: { webhooksDeleted: 1 } };
+const selectWebhookExamplePayload = { result: [{
+	key: "1",
+	label: "New Computer Notifier"
+}] };
+//#endregion
+//#region src/constants.ts
+const MAX_PAGE_SIZE = 1e3;
+const WATERMARK_SKEW_MARGIN_MS = 6e4;
+const WEBHOOK_EVENTS = [
+	"ComputerAdded",
+	"ComputerCheckIn",
+	"ComputerInventoryCompleted",
+	"ComputerPatchPolicyCompleted",
+	"ComputerPolicyFinished",
+	"ComputerPushCapabilityChanged",
+	"MobileDeviceCheckIn",
+	"MobileDeviceCommandCompleted",
+	"MobileDeviceEnrolled",
+	"MobileDeviceInventoryCompleted",
+	"MobileDevicePushSent",
+	"MobileDeviceUnenrolled",
+	"JSSStartup",
+	"JSSShutdown",
+	"DeviceAddedToDEP",
+	"SmartGroupComputerMembershipChange",
+	"SmartGroupMobileDeviceMembershipChange",
+	"SmartGroupUserMembershipChange",
+	"PatchSoftwareTitleUpdated",
+	"PushSent",
+	"RestAPIOperation",
+	"SCEPChallenge"
+];
+const WEBHOOK_AUTH_HEADER = "X-Jamf-Signature";
+const LOOK_BACK_DATE_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/;
+//#endregion
+//#region src/util/clean.ts
+const toOptionalString = (value) => value ? _prismatic_io_spectral.util.types.toString(value) : void 0;
+const toOptionalNumber = (value) => value ? _prismatic_io_spectral.util.types.toNumber(value) : void 0;
+const toOptionalBool = (value) => value === void 0 || value === null || value === "" ? void 0 : _prismatic_io_spectral.util.types.toBool(value);
+const asStringArray = (value) => value;
+const lookBackDateClean = (value) => {
+	const raw = value ? _prismatic_io_spectral.util.types.toString(value).trim() : "";
+	if (!raw) return "";
+	const match = typeof value === "string" ? raw.match(LOOK_BACK_DATE_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.toNumber(yearStr);
+	const month = _prismatic_io_spectral.util.types.toNumber(monthStr);
+	const day = _prismatic_io_spectral.util.types.toNumber(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();
+};
+//#endregion
+//#region src/util/sort.ts
+const sortElementsByLabel = (a, b) => (a.label ?? "") < (b.label ?? "") ? -1 : 1;
+//#endregion
+//#region src/util/elements.ts
+const selectValue = (item, selector) => typeof selector === "function" ? selector(item) : item[selector];
+const mapToSortedElements = (items, keyAttr, labelAttr) => items.map((item) => {
+	const key = _prismatic_io_spectral.util.types.toString(selectValue(item, keyAttr));
+	return {
+		key,
+		label: _prismatic_io_spectral.util.types.toString(selectValue(item, labelAttr), key)
+	};
+}).sort(sortElementsByLabel);
+//#endregion
+//#region src/util/labels.ts
+const humanizeEventLabel = (event) => event.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2");
+const webhookEventOptions = WEBHOOK_EVENTS.map((event) => ({
+	label: humanizeEventLabel(event),
+	value: event
+}));
+//#endregion
+//#region src/util/merge.ts
+const mergeDefined = (existing, overrides) => ({
+	...existing,
+	...Object.fromEntries(Object.entries(overrides).filter(([, value]) => value !== void 0))
+});
+//#endregion
+//#region src/util/pagination.ts
+const paginateResults = async (client, endpoint, fetchAll, params) => {
+	const results = [];
+	let lastResponse = {};
+	let page = 0;
+	let hasMore = true;
+	while (hasMore) {
+		const { data } = await client.get(endpoint, {
+			params: fetchAll ? {
+				...params,
+				page,
+				"page-size": MAX_PAGE_SIZE
+			} : params,
+			paramsSerializer: { indexes: null }
+		});
+		lastResponse = data;
+		results.push(...data.results);
+		page += 1;
+		hasMore = fetchAll && data.results.length > 0 && results.length < data.totalCount;
+	}
+	return {
+		...lastResponse,
+		results
+	};
+};
+//#endregion
+//#region src/util/polling.ts
+const resolveNewComputerChanges = (data) => (data ?? []).map((record) => ({
+	changeType: "created",
+	record
+}));
+const SECOND_MS = 1e3;
+const INVENTORY_ENDPOINT = "/v3/computers-inventory";
+const TRIGGER_NAME = "pollNewComputers";
+const NORMAL_SORT = "general.lastEnrolledDate:asc,id:asc";
+const TIE_SORT = "id:asc";
+const toIso = (epochMs) => new Date(epochMs).toISOString();
+const truncateToSecond = (iso) => toIso(Math.floor(Date.parse(iso) / SECOND_MS) * SECOND_MS);
+const toFilterDate = (iso) => iso.replace(/\.\d+Z$/, "Z");
+const resolveSafeHorizon = (now) => truncateToSecond(toIso(Date.parse(now) - WATERMARK_SKEW_MARGIN_MS));
+const fetchComputerPage = (client) => async ({ filter, sort, pageSize }) => {
+	const { data } = await client.get(INVENTORY_ENDPOINT, {
+		params: {
+			section: ["GENERAL"],
+			filter,
+			sort,
+			page: 0,
+			"page-size": pageSize
+		},
+		paramsSerializer: { indexes: null }
+	});
+	return data.results;
+};
+const enrolledSecond = (record) => {
+	const raw = record.general?.lastEnrolledDate;
+	const at = typeof raw === "string" ? Date.parse(raw) : NaN;
+	return Number.isNaN(at) ? null : Math.floor(at / SECOND_MS) * SECOND_MS;
+};
+const noProgress = (watermark) => /* @__PURE__ */ new Error(`${TRIGGER_NAME}: the watermark cursor cannot advance past ${watermark}: a full page (page size ${MAX_PAGE_SIZE}) held no computer enrolled at or after it, so the same request would return the same page on every poll. Stopping instead of looping.`);
+const normalRound = async (fetchPage, cursor, horizon) => {
+	const watermarkMs = Date.parse(cursor.watermark);
+	if (watermarkMs > Date.parse(horizon)) return {
+		delivered: [],
+		cursor,
+		drained: true
+	};
+	const batch = await fetchPage({
+		filter: `general.lastEnrolledDate=ge="${toFilterDate(cursor.watermark)}";general.lastEnrolledDate=le="${toFilterDate(horizon)}"`,
+		sort: NORMAL_SORT,
+		pageSize: MAX_PAGE_SIZE
+	});
+	const boundary = new Set(cursor.boundaryIds);
+	const delivered = [];
+	let latestMs = watermarkMs;
+	let latestIds = [];
+	for (const record of batch) {
+		const at = enrolledSecond(record);
+		if (at === null) {
+			delivered.push(record);
+			continue;
+		}
+		if (at < watermarkMs) continue;
+		if (!(at === watermarkMs && boundary.has(record.id))) delivered.push(record);
+		if (at > latestMs) {
+			latestMs = at;
+			latestIds = [record.id];
+		} else if (at === latestMs) latestIds.push(record.id);
+	}
+	const full = batch.length >= MAX_PAGE_SIZE;
+	const stuck = latestMs === watermarkMs;
+	if (full && stuck && latestIds.length === 0) throw noProgress(cursor.watermark);
+	const next = stuck ? {
+		watermark: cursor.watermark,
+		boundaryIds: [.../* @__PURE__ */ new Set([...cursor.boundaryIds, ...latestIds])]
+	} : {
+		watermark: toIso(latestMs),
+		boundaryIds: latestIds
+	};
+	if (!full) return {
+		delivered,
+		cursor: next,
+		drained: true
+	};
+	return {
+		delivered,
+		cursor: stuck ? {
+			...next,
+			tieGroup: { lastKey: null }
+		} : next,
+		drained: false
+	};
+};
+const tieRound = async (fetchPage, cursor, horizon) => {
+	const watermarkMs = Date.parse(cursor.watermark);
+	const lastKey = cursor.tieGroup?.lastKey ?? null;
+	const batch = await fetchPage({
+		filter: `general.lastEnrolledDate=ge="${toFilterDate(cursor.watermark)}";general.lastEnrolledDate=lt="${toFilterDate(toIso(watermarkMs + SECOND_MS))}"${lastKey === null ? "" : `;id=gt=${lastKey}`}`,
+		sort: TIE_SORT,
+		pageSize: MAX_PAGE_SIZE
+	});
+	const boundary = new Set(cursor.boundaryIds);
+	const delivered = [];
+	for (const record of batch) {
+		if (enrolledSecond(record) !== watermarkMs || boundary.has(record.id)) continue;
+		delivered.push(record);
+		boundary.add(record.id);
+	}
+	if (batch.length >= 1e3) {
+		const nextKey = batch[batch.length - 1].id;
+		if (nextKey === lastKey) throw noProgress(cursor.watermark);
+		return {
+			delivered,
+			cursor: {
+				watermark: cursor.watermark,
+				boundaryIds: [...boundary],
+				tieGroup: { lastKey: nextKey }
+			},
+			drained: false
+		};
+	}
+	if (watermarkMs < Date.parse(horizon)) return {
+		delivered,
+		cursor: {
+			watermark: toIso(watermarkMs + SECOND_MS),
+			boundaryIds: []
+		},
+		drained: false
+	};
+	return {
+		delivered,
+		cursor: {
+			watermark: cursor.watermark,
+			boundaryIds: [...boundary]
+		},
+		drained: true
+	};
+};
+const drainWatermark = async (fetchPage, start, horizon, maxPages) => {
+	const delivered = [];
+	let cursor = start;
+	for (let page = 0; page < maxPages; page++) {
+		const round = cursor.tieGroup ? await tieRound(fetchPage, cursor, horizon) : await normalRound(fetchPage, cursor, horizon);
+		delivered.push(...round.delivered);
+		cursor = round.cursor;
+		if (round.drained) return {
+			delivered,
+			cursor,
+			drained: true
+		};
+	}
+	return {
+		delivered,
+		cursor,
+		drained: false
+	};
+};
+const resolveStartCursor = (state, incoming, seed) => incoming ?? state.cursor ?? {
+	watermark: truncateToSecond(state.lastPolledAt ?? seed),
+	boundaryIds: state.lastPolledAt ? state.boundaryIds ?? [] : []
+};
+const nextPollingState = (state, seed, result) => {
+	if (result.drained) return {
+		lastPolledAt: result.cursor.watermark,
+		boundaryIds: result.cursor.boundaryIds
+	};
+	return {
+		lastPolledAt: state.lastPolledAt ?? seed,
+		...state.lastPolledAt && state.boundaryIds ? { boundaryIds: state.boundaryIds } : {},
+		cursor: result.cursor
+	};
+};
+//#endregion
+//#region src/util/webhooks.ts
+const escapeXml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+const toWebhookXml = (fields) => {
+	return `<webhook>${Object.entries(fields).filter(([, value]) => value !== void 0).map(([key, value]) => `<${key}>${escapeXml(String(value))}</${key}>`).join("")}</webhook>`;
+};
+const parseWebhookId = (data) => {
+	if (data && typeof data === "object") {
+		const id = data.webhook?.id;
+		if (id !== void 0) return Number(id);
+	}
+	if (typeof data === "string") {
+		const match = data.match(/<id>(\d+)<\/id>/);
+		if (match) return Number(match[1]);
+	}
+};
+const getStoreKey = (flowStableId) => `webhookEvents:${flowStableId}`;
+const buildWebhookName = (flowName, event, suffix) => {
+	const fixed = ` - ${event} - ${suffix}`;
+	return `${flowName.slice(0, 100 - fixed.length)}${fixed}`;
+};
+const createManagedWebhooks = async (context, { connection, events }) => {
+	const client = await createClassicClient(connection, context.debug.enabled);
+	const targetUrl = context.webhookUrls[context.flow.name];
+	const storeKey = getStoreKey(context.flow.stableId);
+	const previous = context.crossFlowState[storeKey];
+	for (const id of previous?.webhookIds ?? []) try {
+		await client.delete(`/webhooks/id/${id}`);
+	} catch (error) {
+		context.logger.warn(`Failed to remove previous webhook ${id}: ${_prismatic_io_spectral.util.types.toString(error)}`);
+	}
+	const webhookAuthValue = (0, node_crypto.randomUUID)();
+	const nameSuffix = (0, node_crypto.randomUUID)().slice(0, 8);
+	const webhookIds = [];
+	try {
+		for (const event of events) {
+			const body = toWebhookXml({
+				name: buildWebhookName(context.flow.name, event, nameSuffix),
+				event,
+				url: targetUrl,
+				content_type: "application/json",
+				enabled: true,
+				authentication_type: "HEADER",
+				header: JSON.stringify({ [WEBHOOK_AUTH_HEADER]: webhookAuthValue })
+			});
+			const { data } = await client.post("/webhooks/id/0", body, { headers: { "Content-Type": "application/xml" } });
+			const id = parseWebhookId(data);
+			if (id != null) webhookIds.push(id);
+		}
+	} catch (error) {
+		for (const id of webhookIds) try {
+			await client.delete(`/webhooks/id/${id}`);
+		} catch {}
+		throw error;
+	}
+	context.crossFlowState[storeKey] = {
+		webhookIds,
+		webhookAuthValue
+	};
+	return { crossFlowState: context.crossFlowState };
+};
+const deleteManagedWebhooks = async (context, { connection }) => {
+	const client = await createClassicClient(connection, context.debug.enabled);
+	const storeKey = getStoreKey(context.flow.stableId);
+	const state = context.crossFlowState[storeKey];
+	for (const id of state?.webhookIds ?? []) try {
+		await client.delete(`/webhooks/id/${id}`);
+	} catch (error) {
+		context.logger.error(`Failed to delete webhook ${id}: ${_prismatic_io_spectral.util.types.toString(error)}`);
+	}
+	context.crossFlowState[storeKey] = void 0;
+	return { crossFlowState: context.crossFlowState };
+};
+//#endregion
+//#region src/inputs/common.ts
+const connection = (0, _prismatic_io_spectral.input)({
+	label: "Connection",
+	type: "connection",
+	required: true,
+	comments: "The Jamf Pro connection to use."
+});
+const resourceId = (0, _prismatic_io_spectral.input)({
+	label: "ID",
+	type: "string",
+	required: true,
+	comments: "The unique identifier of the resource.",
+	clean: _prismatic_io_spectral.util.types.toString,
+	placeholder: "Enter resource ID",
+	example: "1"
+});
+const page = (0, _prismatic_io_spectral.input)({
+	label: "Page",
+	type: "string",
+	required: false,
+	default: "0",
+	comments: "The zero-indexed page number for paginated results. Page 0 is the first page.",
+	clean: toOptionalString,
+	placeholder: "Enter page number",
+	example: "0"
+});
+const pageSize = (0, _prismatic_io_spectral.input)({
+	label: "Page Size",
+	type: "string",
+	required: false,
+	comments: "The maximum number of results to return per page. Maximum 1000.",
+	clean: toOptionalString,
+	placeholder: "Enter page size",
+	example: "100",
+	default: "100"
+});
+const filter = (0, _prismatic_io_spectral.input)({
+	label: "Filter",
+	type: "string",
+	required: false,
+	comments: "An RSQL filter expression to narrow results. Example: name==\"Apps*\" or id>=5. Leave blank to return all results.",
+	clean: toOptionalString,
+	placeholder: "Enter filter expression",
+	example: "name==\"Acme*\""
+});
+const sort = (0, _prismatic_io_spectral.input)({
+	label: "Sort",
+	type: "string",
+	required: false,
+	comments: "The sort criteria in the format property:asc or property:desc. Multiple criteria are comma-separated.",
+	clean: toOptionalString,
+	placeholder: "Enter sort criteria",
+	example: "name:asc,id:desc"
+});
+const fetchAll = (0, _prismatic_io_spectral.input)({
+	label: "Fetch All",
+	type: "boolean",
+	required: false,
+	default: "false",
+	comments: "If true, fetch every page of results and ignore the Page and Page Size inputs. If false, return a single page.",
+	clean: _prismatic_io_spectral.util.types.toBool
+});
+//#endregion
+//#region src/inputs/categories.ts
+const categoryName = (0, _prismatic_io_spectral.input)({
+	label: "Name",
+	type: "string",
+	required: true,
+	comments: "The display name used to identify the category in Jamf Pro.",
+	clean: _prismatic_io_spectral.util.types.toString,
+	placeholder: "Enter category name",
+	example: "Productivity Apps"
+});
+const priority = (0, _prismatic_io_spectral.input)({
+	label: "Priority",
+	type: "string",
+	required: false,
+	default: "9",
+	comments: "The sort order weight for the category. Lower numbers appear first.",
+	clean: _prismatic_io_spectral.util.types.toNumber,
+	placeholder: "Enter priority",
+	example: "9"
+});
+const categoryResourceId = {
+	...resourceId,
+	label: "Category",
+	comments: "The unique identifier of the category.",
+	dataSource: "selectCategory"
+};
+const createCategoryInputs = {
+	connection,
+	categoryName,
+	priority
+};
+const deleteCategoryInputs = {
+	connection,
+	resourceId: categoryResourceId
+};
+const getCategoryInputs = {
+	connection,
+	resourceId: categoryResourceId
+};
+const listCategoriesInputs = {
+	connection,
+	fetchAll,
+	pagination: (0, _prismatic_io_spectral.structuredObjectInput)({
+		label: "Pagination",
+		required: false,
+		comments: "Page and page-size controls.",
+		inputs: {
+			page,
+			pageSize
+		}
+	}),
+	sort,
+	filter
+};
+const updateCategoryInputs = {
+	connection,
+	resourceId: categoryResourceId,
+	categoryName: {
+		...categoryName,
+		required: false,
+		clean: toOptionalString
+	},
+	priority: {
+		...priority,
+		default: void 0,
+		clean: toOptionalNumber
+	}
+};
+//#endregion
+//#region src/inputs/computers.ts
+const section$1 = (0, _prismatic_io_spectral.input)({
+	label: "Section",
+	type: "string",
+	collection: "valuelist",
+	default: ["GENERAL"],
+	model: [
+		{
+			label: "GENERAL",
+			value: "GENERAL"
+		},
+		{
+			label: "DISK_ENCRYPTION",
+			value: "DISK_ENCRYPTION"
+		},
+		{
+			label: "PURCHASING",
+			value: "PURCHASING"
+		},
+		{
+			label: "APPLICATIONS",
+			value: "APPLICATIONS"
+		},
+		{
+			label: "STORAGE",
+			value: "STORAGE"
+		},
+		{
+			label: "USER_AND_LOCATION",
+			value: "USER_AND_LOCATION"
+		},
+		{
+			label: "CONFIGURATION_PROFILES",
+			value: "CONFIGURATION_PROFILES"
+		},
+		{
+			label: "PRINTERS",
+			value: "PRINTERS"
+		},
+		{
+			label: "SERVICES",
+			value: "SERVICES"
+		},
+		{
+			label: "HARDWARE",
+			value: "HARDWARE"
+		},
+		{
+			label: "LOCAL_USER_ACCOUNTS",
+			value: "LOCAL_USER_ACCOUNTS"
+		},
+		{
+			label: "CERTIFICATES",
+			value: "CERTIFICATES"
+		},
+		{
+			label: "ATTACHMENTS",
+			value: "ATTACHMENTS"
+		},
+		{
+			label: "PACKAGE_RECEIPTS",
+			value: "PACKAGE_RECEIPTS"
+		},
+		{
+			label: "SECURITY",
+			value: "SECURITY"
+		},
+		{
+			label: "OPERATING_SYSTEM",
+			value: "OPERATING_SYSTEM"
+		},
+		{
+			label: "LICENSED_SOFTWARE",
+			value: "LICENSED_SOFTWARE"
+		},
+		{
+			label: "IBEACONS",
+			value: "IBEACONS"
+		},
+		{
+			label: "SOFTWARE_UPDATES",
+			value: "SOFTWARE_UPDATES"
+		},
+		{
+			label: "EXTENSION_ATTRIBUTES",
+			value: "EXTENSION_ATTRIBUTES"
+		},
+		{
+			label: "CONTENT_CACHING",
+			value: "CONTENT_CACHING"
+		},
+		{
+			label: "GROUP_MEMBERSHIPS",
+			value: "GROUP_MEMBERSHIPS"
+		}
+	],
+	comments: "Section of computer details to include in the response. If not specified, General section data is returned.",
+	clean: asStringArray,
+	placeholder: "Enter section",
+	example: "GENERAL"
+});
+const computerUpdateBody = (0, _prismatic_io_spectral.input)({
+	label: "Update Data",
+	language: "json",
+	type: "code",
+	required: true,
+	comments: "JSON object with the computer inventory fields to update. Only the provided fields will be modified (PATCH semantics).",
+	clean: _prismatic_io_spectral.util.types.toObject,
+	placeholder: "Enter update data as JSON",
+	example: JSON.stringify({
+		udid: "45436edf-864e-4364-982a-330b01d39e65",
+		general: {
+			name: "Boalime",
+			lastIpAddress: "247.185.82.186",
+			barcode1: "5 12345 678900",
+			barcode2: "5 12345 678900",
+			assetTag: "304822",
+			managed: true,
+			siteId: "1"
+		},
+		userAndLocation: {
+			username: "Madison Anderson",
+			realname: "13-inch MacBook",
+			email: "email@com.pl",
+			position: "IT Team Lead",
+			phone: "123-456-789",
+			departmentId: "1",
+			buildingId: "1",
+			room: "5",
+			extensionAttributes: [{
+				definitionId: "23",
+				values: ["foo", "bar"]
+			}]
+		},
+		hardware: {
+			networkAdapterType: "Foo",
+			macAddress: "6A:2C:4B:B7:65:B5",
+			altNetworkAdapterType: "Bar",
+			altMacAddress: "82:45:58:44:dc:01",
+			extensionAttributes: [{
+				definitionId: "23",
+				values: ["foo", "bar"]
+			}]
+		}
+	}, null, 2)
+});
+const listComputersInputs = {
+	connection,
+	fetchAll,
+	pagination: (0, _prismatic_io_spectral.structuredObjectInput)({
+		label: "Pagination",
+		required: false,
+		comments: "Page and page-size controls.",
+		inputs: {
+			page,
+			pageSize
+		}
+	}),
+	sort,
+	filter,
+	section: section$1
+};
+const computerResourceId = {
+	...resourceId,
+	label: "Computer",
+	comments: "The unique identifier of the computer.",
+	dataSource: "selectComputer"
+};
+const getComputerInputs = {
+	connection,
+	resourceId: computerResourceId,
+	section: section$1
+};
+const updateComputerInputs = {
+	connection,
+	resourceId: computerResourceId,
+	computerUpdateBody
+};
+//#endregion
+//#region src/inputs/dataSources.ts
+const selectCategoryInputs = { connection };
+const selectComputerInputs = { connection };
+const selectDepartmentInputs = { connection };
+const selectMobileDeviceInputs = { connection };
+const selectPackageInputs = { connection };
+const selectScriptInputs = { connection };
+const selectWebhookInputs = { connection };
+//#endregion
+//#region src/inputs/departments.ts
+const departmentName = (0, _prismatic_io_spectral.input)({
+	label: "Name",
+	type: "string",
+	required: true,
+	comments: "The display name used to identify the department in Jamf Pro.",
+	clean: _prismatic_io_spectral.util.types.toString,
+	placeholder: "Enter department name",
+	example: "Information Technology"
+});
+const departmentResourceId = {
+	...resourceId,
+	label: "Department",
+	comments: "The unique identifier of the department.",
+	dataSource: "selectDepartment"
+};
+const createDepartmentInputs = {
+	connection,
+	departmentName
+};
+const deleteDepartmentInputs = {
+	connection,
+	resourceId: departmentResourceId
+};
+const getDepartmentInputs = {
+	connection,
+	resourceId: departmentResourceId
+};
+const listDepartmentsInputs = {
+	connection,
+	fetchAll,
+	pagination: (0, _prismatic_io_spectral.structuredObjectInput)({
+		label: "Pagination",
+		required: false,
+		comments: "Page and page-size controls.",
+		inputs: {
+			page,
+			pageSize
+		}
+	}),
+	sort,
+	filter
+};
+const updateDepartmentInputs = {
+	connection,
+	resourceId: departmentResourceId,
+	departmentName
+};
+//#endregion
+//#region src/inputs/misc.ts
+const { debugRequest: _, ...httpInputs } = _prismatic_io_spectral_http.inputs;
+const rawRequestInputs = {
+	connection,
+	apiType: (0, _prismatic_io_spectral.input)({
+		label: "API",
+		type: "string",
+		required: false,
+		default: "api",
+		model: [{
+			label: "Pro API",
+			value: "api"
+		}, {
+			label: "Classic API",
+			value: "JSSResource"
+		}],
+		comments: "Which Jamf Pro API to target. The Pro API uses the /api base path; the Classic API uses /JSSResource.",
+		clean: _prismatic_io_spectral.util.types.toString
+	}),
+	...httpInputs,
+	url: {
+		...httpInputs.url,
+		comments: "The API path only (e.g., /v1/computers-inventory for the Pro API, or /computers/id/1 for the Classic API). The base URL and selected API prefix are added automatically.",
+		example: "/v1/computers-inventory"
+	}
+};
+//#endregion
+//#region src/inputs/mobileDevices.ts
+const section = (0, _prismatic_io_spectral.input)({
+	label: "Section",
+	type: "string",
+	collection: "valuelist",
+	default: ["GENERAL"],
+	model: [
+		{
+			label: "GENERAL",
+			value: "GENERAL"
+		},
+		{
+			label: "HARDWARE",
+			value: "HARDWARE"
+		},
+		{
+			label: "USER_AND_LOCATION",
+			value: "USER_AND_LOCATION"
+		},
+		{
+			label: "PURCHASING",
+			value: "PURCHASING"
+		},
+		{
+			label: "SECURITY",
+			value: "SECURITY"
+		},
+		{
+			label: "APPLICATIONS",
+			value: "APPLICATIONS"
+		},
+		{
+			label: "EBOOKS",
+			value: "EBOOKS"
+		},
+		{
+			label: "NETWORK",
+			value: "NETWORK"
+		},
+		{
+			label: "SERVICE_SUBSCRIPTIONS",
+			value: "SERVICE_SUBSCRIPTIONS"
+		},
+		{
+			label: "CERTIFICATES",
+			value: "CERTIFICATES"
+		},
+		{
+			label: "PROFILES",
+			value: "PROFILES"
+		},
+		{
+			label: "USER_PROFILES",
+			value: "USER_PROFILES"
+		},
+		{
+			label: "PROVISIONING_PROFILES",
+			value: "PROVISIONING_PROFILES"
+		},
+		{
+			label: "SHARED_USERS",
+			value: "SHARED_USERS"
+		},
+		{
+			label: "GROUPS",
+			value: "GROUPS"
+		},
+		{
+			label: "EXTENSION_ATTRIBUTES",
+			value: "EXTENSION_ATTRIBUTES"
+		}
+	],
+	comments: "Section of mobile device details to include in the response. If not specified, General section data is returned.",
+	clean: asStringArray,
+	placeholder: "Enter section",
+	example: "GENERAL"
+});
+const mobileDeviceResourceId = {
+	...resourceId,
+	label: "Mobile Device",
+	comments: "The unique identifier of the mobile device.",
+	dataSource: "selectMobileDevice"
+};
+const listMobileDevicesInputs = {
+	connection,
+	fetchAll,
+	pagination: (0, _prismatic_io_spectral.structuredObjectInput)({
+		label: "Pagination",
+		required: false,
+		comments: "Page and page-size controls.",
+		inputs: {
+			page,
+			pageSize
+		}
+	}),
+	sort,
+	filter,
+	section
+};
+const getMobileDeviceInputs = {
+	connection,
+	resourceId: mobileDeviceResourceId
+};
+//#endregion
+//#region src/inputs/packages.ts
+const optionalBoolean$1 = (label, comments) => (0, _prismatic_io_spectral.input)({
+	label,
+	type: "string",
+	required: false,
+	model: [{
+		label: "True",
+		value: "true"
+	}, {
+		label: "False",
+		value: "false"
+	}],
+	comments,
+	clean: toOptionalBool
+});
+const packageName = (0, _prismatic_io_spectral.input)({
+	label: "Package Name",
+	type: "string",
+	required: true,
+	comments: "The display name of the package as shown in Jamf Pro.",
+	clean: _prismatic_io_spectral.util.types.toString,
+	placeholder: "Enter package name",
+	example: "Google Chrome 120.0.pkg"
+});
+const packageFileName = (0, _prismatic_io_spectral.input)({
+	label: "File Name",
+	type: "string",
+	required: true,
+	comments: "The filename of the package file on the Jamf distribution point (e.g., GoogleChrome.pkg).",
+	clean: _prismatic_io_spectral.util.types.toString,
+	placeholder: "Enter file name",
+	example: "GoogleChrome-120.0.6099.199.pkg"
+});
+const packageCategoryId = (0, _prismatic_io_spectral.input)({
+	label: "Category ID",
+	type: "string",
+	required: false,
+	dataSource: "selectCategory",
+	comments: "The unique identifier of the category to assign to this package.",
+	clean: toOptionalString,
+	placeholder: "Enter category ID",
+	example: "3"
+});
+const packageInfo = (0, _prismatic_io_spectral.input)({
+	label: "Info",
+	type: "string",
+	required: false,
+	comments: "A description of the package displayed to administrators in Jamf Pro.",
+	clean: toOptionalString,
+	placeholder: "Enter package info",
+	example: "Google Chrome browser installer."
+});
+const packageNotes = (0, _prismatic_io_spectral.input)({
+	label: "Notes",
+	type: "string",
+	required: false,
+	comments: "Internal notes about the package visible only to administrators.",
+	clean: toOptionalString,
+	placeholder: "Enter notes",
+	example: "Downloaded from https://dl.google.com/chrome/mac/stable/"
+});
+const packagePriority = (0, _prismatic_io_spectral.input)({
+	label: "Priority",
+	type: "string",
+	required: false,
+	comments: "Installation priority from 1 (highest) to 20 (lowest). Defaults to 10.",
+	clean: toOptionalNumber,
+	placeholder: "Enter priority (1–20)",
+	example: "10"
+});
+const createPackageInputs = {
+	connection,
+	packageName,
+	packageFileName,
+	packageCategoryId,
+	additionalFields: (0, _prismatic_io_spectral.structuredObjectInput)({
+		label: "Additional Fields",
+		required: false,
+		comments: "Additional optional fields: includes Priority, Info, Notes, Reboot Required, OS Install, Fill User Template, Suppress Updates, Suppress EULA, Suppress From Dock, and Suppress Registration.",
+		inputs: {
+			packagePriority,
+			packageInfo,
+			packageNotes,
+			packageRebootRequired: (0, _prismatic_io_spectral.input)({
+				label: "Reboot Required",
+				type: "boolean",
+				required: false,
+				comments: "Whether the device must reboot after installing this package.",
+				clean: _prismatic_io_spectral.util.types.toBool
+			}),
+			packageOsInstall: (0, _prismatic_io_spectral.input)({
+				label: "OS Install",
+				type: "boolean",
+				required: false,
+				comments: "Whether this package is an OS installer.",
+				clean: _prismatic_io_spectral.util.types.toBool
+			}),
+			packageFillUserTemplate: (0, _prismatic_io_spectral.input)({
+				label: "Fill User Template",
+				type: "boolean",
+				required: false,
+				comments: "Whether to fill the user template with the package contents.",
+				clean: _prismatic_io_spectral.util.types.toBool
+			}),
+			packageSuppressUpdates: (0, _prismatic_io_spectral.input)({
+				label: "Suppress Updates",
+				type: "boolean",
+				required: false,
+				comments: "Whether to suppress software updates during installation.",
+				clean: _prismatic_io_spectral.util.types.toBool
+			}),
+			packageSuppressEula: (0, _prismatic_io_spectral.input)({
+				label: "Suppress EULA",
+				type: "boolean",
+				required: false,
+				comments: "Whether to suppress the End User License Agreement during installation.",
+				clean: _prismatic_io_spectral.util.types.toBool
+			}),
+			packageSuppressFromDock: (0, _prismatic_io_spectral.input)({
+				label: "Suppress From Dock",
+				type: "boolean",
+				required: false,
+				comments: "Whether to suppress the package icon from the Dock during installation.",
+				clean: _prismatic_io_spectral.util.types.toBool
+			}),
+			packageSuppressRegistration: (0, _prismatic_io_spectral.input)({
+				label: "Suppress Registration",
+				type: "boolean",
+				required: false,
+				comments: "Whether to suppress the registration window during installation.",
+				clean: _prismatic_io_spectral.util.types.toBool
+			})
+		}
+	})
+};
+const packageResourceId = {
+	...resourceId,
+	label: "Package",
+	comments: "The unique identifier of the package.",
+	dataSource: "selectPackage"
+};
+const deletePackageInputs = {
+	connection,
+	resourceId: packageResourceId
+};
+const getPackageInputs = {
+	connection,
+	resourceId: packageResourceId
+};
+const listPackagesInputs = {
+	connection,
+	fetchAll,
+	pagination: (0, _prismatic_io_spectral.structuredObjectInput)({
+		label: "Pagination",
+		required: false,
+		comments: "Page and page-size controls.",
+		inputs: {
+			page,
+			pageSize
+		}
+	}),
+	sort,
+	filter
+};
+const updatePackageInputs = {
+	connection,
+	resourceId: packageResourceId,
+	packageCategoryId,
+	additionalFields: (0, _prismatic_io_spectral.structuredObjectInput)({
+		label: "Additional Fields",
+		required: false,
+		comments: "Additional optional fields: includes Package Name, File Name, Priority, Info, Notes, Reboot Required, OS Install, Fill User Template, Suppress Updates, Suppress EULA, Suppress From Dock, and Suppress Registration.",
+		inputs: {
+			packageName: {
+				...packageName,
+				required: false,
+				clean: toOptionalString
+			},
+			packageFileName: {
+				...packageFileName,
+				required: false,
+				clean: toOptionalString
+			},
+			packagePriority,
+			packageInfo,
+			packageNotes,
+			packageRebootRequired: optionalBoolean$1("Reboot Required", "Whether the device must reboot after installing this package."),
+			packageOsInstall: optionalBoolean$1("OS Install", "Whether this package is an OS installer."),
+			packageFillUserTemplate: optionalBoolean$1("Fill User Template", "Whether to fill the user template with the package contents."),
+			packageSuppressUpdates: optionalBoolean$1("Suppress Updates", "Whether to suppress software updates during installation."),
+			packageSuppressEula: optionalBoolean$1("Suppress EULA", "Whether to suppress the End User License Agreement during installation."),
+			packageSuppressFromDock: optionalBoolean$1("Suppress From Dock", "Whether to suppress the package icon from the Dock during installation."),
+			packageSuppressRegistration: optionalBoolean$1("Suppress Registration", "Whether to suppress the registration window during installation.")
+		}
+	})
+};
+//#endregion
+//#region src/inputs/scripts.ts
+const scriptName = (0, _prismatic_io_spectral.input)({
+	label: "Name",
+	type: "string",
+	required: true,
+	comments: "The display name used to identify the script in Jamf Pro.",
+	clean: _prismatic_io_spectral.util.types.toString,
+	placeholder: "Enter script name",
+	example: "Install Chrome"
+});
+const scriptContents = (0, _prismatic_io_spectral.input)({
+	label: "Script Contents",
+	type: "text",
+	required: false,
+	comments: "The shell script body. Include the shebang line (e.g., #!/bin/bash).",
+	clean: toOptionalString,
+	placeholder: "Enter script contents",
+	example: "#!/bin/bash\n/usr/local/bin/install-app.sh"
+});
+const scriptCategoryId = (0, _prismatic_io_spectral.input)({
+	label: "Category ID",
+	type: "string",
+	required: false,
+	dataSource: "selectCategory",
+	comments: "The unique identifier of the category to assign to this script.",
+	clean: toOptionalString,
+	placeholder: "Enter category ID",
+	example: "3"
+});
+const scriptPriority = (0, _prismatic_io_spectral.input)({
+	label: "Priority",
+	type: "string",
+	required: false,
+	default: "AFTER",
+	model: [
+		{
+			label: "BEFORE",
+			value: "BEFORE"
+		},
+		{
+			label: "AFTER",
+			value: "AFTER"
+		},
+		{
+			label: "AT_REBOOT",
+			value: "AT_REBOOT"
+		}
+	],
+	comments: "When the script runs relative to the policy.",
+	clean: toOptionalString,
+	placeholder: "Enter priority",
+	example: "AFTER"
+});
+const scriptInfo = (0, _prismatic_io_spectral.input)({
+	label: "Info",
+	type: "string",
+	required: false,
+	comments: "A description of the script displayed to administrators in Jamf Pro.",
+	clean: toOptionalString,
+	placeholder: "Enter script info",
+	example: "Installs Google Chrome from the vendor CDN."
+});
+const scriptNotes = (0, _prismatic_io_spectral.input)({
+	label: "Notes",
+	type: "string",
+	required: false,
+	comments: "Internal notes about the script visible only to administrators.",
+	clean: toOptionalString,
+	placeholder: "Enter notes",
+	example: "Updated 2026-01-15 to support macOS 15."
+});
+const createScriptInputs = {
+	connection,
+	scriptName,
+	scriptCategoryId,
+	additionalFields: (0, _prismatic_io_spectral.structuredObjectInput)({
+		label: "Additional Fields",
+		required: false,
+		comments: "Additional optional fields: includes Script Contents, Priority, Info, and Notes.",
+		inputs: {
+			scriptContents,
+			scriptPriority,
+			scriptInfo,
+			scriptNotes
+		}
+	})
+};
+const scriptResourceId = {
+	...resourceId,
+	label: "Script",
+	comments: "The unique identifier of the script.",
+	dataSource: "selectScript"
+};
+const deleteScriptInputs = {
+	connection,
+	resourceId: scriptResourceId
+};
+const getScriptInputs = {
+	connection,
+	resourceId: scriptResourceId
+};
+const listScriptsInputs = {
+	connection,
+	fetchAll,
+	pagination: (0, _prismatic_io_spectral.structuredObjectInput)({
+		label: "Pagination",
+		required: false,
+		comments: "Page and page-size controls.",
+		inputs: {
+			page,
+			pageSize
+		}
+	}),
+	sort,
+	filter
+};
+const updateScriptInputs = {
+	connection,
+	resourceId: scriptResourceId,
+	scriptCategoryId,
+	additionalFields: (0, _prismatic_io_spectral.structuredObjectInput)({
+		label: "Additional Fields",
+		required: false,
+		comments: "Additional optional fields: includes Name, Script Contents, Priority, Info, and Notes.",
+		inputs: {
+			scriptName: {
+				...scriptName,
+				required: false,
+				clean: toOptionalString
+			},
+			scriptContents,
+			scriptPriority: {
+				...scriptPriority,
+				default: void 0
+			},
+			scriptInfo,
+			scriptNotes
+		}
+	})
+};
+const webhookInputs = {
+	authHeaderName: (0, _prismatic_io_spectral.input)({
+		label: "Auth Header Name",
+		type: "string",
+		required: false,
+		comments: "Name of the header Jamf Pro sends for header authentication (must match the webhook's configured header). Leave blank to accept all incoming requests.",
+		clean: toOptionalString,
+		placeholder: "X-Jamf-Signature",
+		example: "X-Jamf-Signature"
+	}),
+	authHeaderValue: (0, _prismatic_io_spectral.input)({
+		label: "Auth Header Value",
+		type: "string",
+		required: false,
+		comments: "Expected value of the authentication header. Incoming requests whose header does not match are rejected. Required only if an Auth Header Name is set.",
+		clean: toOptionalString,
+		placeholder: "Enter the expected header value"
+	})
+};
+const events = (0, _prismatic_io_spectral.input)({
+	label: "Events",
+	type: "string",
+	collection: "valuelist",
+	required: true,
+	model: webhookEventOptions,
+	default: ["ComputerAdded"],
+	comments: "The Jamf Pro events to subscribe to. One webhook is created per selected event.",
+	clean: asStringArray
+});
+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 computer enrolled on or after this date once.",
+	example: "2026-01-01",
+	clean: lookBackDateClean
+});
+const webhookEventsInputs = {
+	connection,
+	events
+};
+const pollComputersInputs = {
+	connection,
+	lookBackDate
+};
+const pollMobileDevicesInputs = { connection };
+const listUsersInputs = {
+	connection,
+	fetchAll,
+	pagination: (0, _prismatic_io_spectral.structuredObjectInput)({
+		label: "Pagination",
+		required: false,
+		comments: "Page and page-size controls.",
+		inputs: {
+			page,
+			pageSize
+		}
+	}),
+	sort,
+	filter
+};
+//#endregion
+//#region src/inputs/webhooks.ts
+const optionalBoolean = (label, comments) => (0, _prismatic_io_spectral.input)({
+	label,
+	type: "string",
+	required: false,
+	model: [{
+		label: "True",
+		value: "true"
+	}, {
+		label: "False",
+		value: "false"
+	}],
+	comments,
+	clean: toOptionalBool
+});
+const webhookName = (0, _prismatic_io_spectral.input)({
+	label: "Name",
+	type: "string",
+	required: true,
+	comments: "The display name used to identify the webhook in Jamf Pro.",
+	clean: _prismatic_io_spectral.util.types.toString,
+	placeholder: "Enter webhook name",
+	example: "New Computer Notifier"
+});
+const webhookEvent = (0, _prismatic_io_spectral.input)({
+	label: "Event",
+	type: "string",
+	required: true,
+	model: webhookEventOptions,
+	comments: "The Jamf Pro event that triggers this webhook.",
+	clean: _prismatic_io_spectral.util.types.toString,
+	placeholder: "Select an event",
+	example: "ComputerAdded"
+});
+const webhookUrl = (0, _prismatic_io_spectral.input)({
+	label: "URL",
+	type: "string",
+	required: true,
+	comments: "The destination URL that Jamf Pro sends webhook events to.",
+	clean: _prismatic_io_spectral.util.types.toString,
+	placeholder: "https://example.com/webhook",
+	example: "https://example.com/webhook"
+});
+const webhookContentType = (0, _prismatic_io_spectral.input)({
+	label: "Content Type",
+	type: "string",
+	required: false,
+	default: "application/json",
+	model: [{
+		label: "JSON",
+		value: "application/json"
+	}, {
+		label: "XML",
+		value: "text/xml"
+	}],
+	comments: "The payload format Jamf Pro delivers events in.",
+	clean: _prismatic_io_spectral.util.types.toString,
+	example: "application/json"
+});
+const webhookEnabled = (0, _prismatic_io_spectral.input)({
+	label: "Enabled",
+	type: "boolean",
+	required: false,
+	default: "true",
+	comments: "Whether the webhook is active and delivering events.",
+	clean: _prismatic_io_spectral.util.types.toBool
+});
+const webhookAuthType = (0, _prismatic_io_spectral.input)({
+	label: "Authentication Type",
+	type: "string",
+	required: false,
+	default: "NONE",
+	model: [{
+		label: "None",
+		value: "NONE"
+	}, {
+		label: "Header",
+		value: "HEADER"
+	}],
+	comments: "How Jamf Pro authenticates to the destination URL. Header authentication sends a custom header with every event.",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const webhookAuthHeaderName = (0, _prismatic_io_spectral.input)({
+	label: "Auth Header Name",
+	type: "string",
+	required: false,
+	comments: "Name of the header Jamf Pro sends when Authentication Type is Header. Required when using Header authentication.",
+	clean: toOptionalString,
+	placeholder: "X-Jamf-Signature",
+	example: "X-Jamf-Signature"
+});
+const webhookAuthHeaderValue = (0, _prismatic_io_spectral.input)({
+	label: "Auth Header Value",
+	type: "string",
+	required: false,
+	comments: "Value of the header Jamf Pro sends when Authentication Type is Header. Required when using Header authentication.",
+	clean: toOptionalString,
+	placeholder: "Enter the header value"
+});
+const webhookResourceId = {
+	...resourceId,
+	label: "Webhook",
+	comments: "The unique identifier of the webhook.",
+	dataSource: "selectWebhook"
+};
+const createWebhookInputs = {
+	connection,
+	webhookName,
+	webhookEvent,
+	webhookUrl,
+	additionalFields: (0, _prismatic_io_spectral.structuredObjectInput)({
+		label: "Additional Fields",
+		required: false,
+		comments: "Additional optional fields: includes Content Type, Enabled, Authentication Type, Auth Header Name, and Auth Header Value.",
+		inputs: {
+			webhookContentType,
+			webhookEnabled,
+			webhookAuthType,
+			webhookAuthHeaderName,
+			webhookAuthHeaderValue
+		}
+	})
+};
+const getWebhookInputs = {
+	connection,
+	resourceId: webhookResourceId
+};
+const listWebhooksInputs = { connection };
+const deleteInstancedWebhooksInputs = { connection };
+const deleteWebhookInputs = {
+	connection,
+	resourceId: webhookResourceId
+};
+const updateWebhookInputs = {
+	connection,
+	resourceId: webhookResourceId,
+	additionalFields: (0, _prismatic_io_spectral.structuredObjectInput)({
+		label: "Additional Fields",
+		required: false,
+		comments: "Additional optional fields: includes Name, Event, URL, Content Type, and Enabled.",
+		inputs: {
+			webhookName: {
+				...webhookName,
+				required: false,
+				clean: toOptionalString
+			},
+			webhookEvent: {
+				...webhookEvent,
+				required: false,
+				clean: toOptionalString
+			},
+			webhookUrl: {
+				...webhookUrl,
+				required: false,
+				clean: toOptionalString
+			},
+			webhookContentType: {
+				...webhookContentType,
+				default: void 0,
+				clean: toOptionalString
+			},
+			webhookEnabled: optionalBoolean("Enabled", "Whether the webhook is active and delivering events.")
+		}
+	})
+};
+//#endregion
+//#region src/actions/categories/createCategory.ts
+const createCategory = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Create Category",
+		description: "Create a new category."
+	},
+	inputs: createCategoryInputs,
+	perform: async (context, { connection, categoryName, priority }) => {
+		const { data } = await (await createClient(connection, context.debug.enabled)).post("/v1/categories", {
+			name: categoryName,
+			priority
+		});
+		return { data };
+	},
+	examplePayload: createCategoryExamplePayload
+});
+//#endregion
+//#region src/actions/categories/deleteCategory.ts
+const deleteCategory = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Delete Category",
+		description: "Delete a category by ID."
+	},
+	inputs: deleteCategoryInputs,
+	perform: async (context, { connection, resourceId }) => {
+		await (await createClient(connection, context.debug.enabled)).delete(`/v1/categories/${resourceId}`);
+		return { data: `Successfully deleted category ${resourceId}` };
+	},
+	examplePayload: deleteCategoryExamplePayload
+});
+//#endregion
+//#region src/actions/categories/getCategory.ts
+const getCategory = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Get Category",
+		description: "Get a single category by ID."
+	},
+	inputs: getCategoryInputs,
+	perform: async (context, { connection, resourceId }) => {
+		const { data } = await (await createClient(connection, context.debug.enabled)).get(`/v1/categories/${resourceId}`);
+		return { data };
+	},
+	examplePayload: getCategoryExamplePayload
+});
+//#endregion
+//#region src/actions/categories/listCategories.ts
+const listCategories = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "List Categories",
+		description: "List all categories with optional filtering and pagination."
+	},
+	inputs: listCategoriesInputs,
+	perform: async (context, { connection, pagination, sort, filter, fetchAll }) => {
+		return { data: await paginateResults(await createClient(connection, context.debug.enabled), "/v1/categories", fetchAll, {
+			page: pagination.page,
+			"page-size": pagination.pageSize,
+			sort,
+			filter
+		}) };
+	},
+	examplePayload: listCategoriesExamplePayload
+});
+//#endregion
+//#region src/actions/categories/updateCategory.ts
+const updateCategory = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Update Category",
+		description: "Update an existing category."
+	},
+	inputs: updateCategoryInputs,
+	perform: async (context, { connection, resourceId, categoryName, priority }) => {
+		const client = await createClient(connection, context.debug.enabled);
+		const { data: existing } = await client.get(`/v1/categories/${resourceId}`);
+		const { data } = await client.put(`/v1/categories/${resourceId}`, mergeDefined(existing, {
+			name: categoryName,
+			priority
+		}));
+		return { data };
+	},
+	examplePayload: updateCategoryExamplePayload
+});
+//#endregion
+//#region src/actions/categories/index.ts
+var categories_exports = /* @__PURE__ */ __exportAll({
+	createCategory: () => createCategory,
+	deleteCategory: () => deleteCategory,
+	getCategory: () => getCategory,
+	listCategories: () => listCategories,
+	updateCategory: () => updateCategory
+});
+//#endregion
+//#region src/actions/computers/getComputer.ts
+const getComputer = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Get Computer",
+		description: "Get a single computer inventory record by ID."
+	},
+	inputs: getComputerInputs,
+	perform: async (context, { connection, resourceId, section }) => {
+		const { data } = await (await createClient(connection, context.debug.enabled)).get(`/v3/computers-inventory/${resourceId}`, {
+			params: { section },
+			paramsSerializer: { indexes: null }
+		});
+		return { data };
+	},
+	examplePayload: getComputerExamplePayload
+});
+//#endregion
+//#region src/actions/computers/listComputers.ts
+const listComputers = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "List Computers",
+		description: "List computer inventory records with optional filtering and pagination."
+	},
+	inputs: listComputersInputs,
+	perform: async (context, { connection, pagination, sort, filter, section, fetchAll }) => {
+		return { data: await paginateResults(await createClient(connection, context.debug.enabled), "/v3/computers-inventory", fetchAll, {
+			page: pagination.page,
+			"page-size": pagination.pageSize,
+			sort,
+			filter,
+			section
+		}) };
+	},
+	examplePayload: listComputersExamplePayload
+});
+//#endregion
+//#region src/actions/computers/updateComputer.ts
+const updateComputer = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Update Computer",
+		description: "Update specific fields of a computer inventory record. Only the provided fields are modified."
+	},
+	inputs: updateComputerInputs,
+	perform: async (context, { connection, resourceId, computerUpdateBody }) => {
+		await (await createClient(connection, context.debug.enabled)).patch(`/v3/computers-inventory-detail/${resourceId}`, computerUpdateBody);
+		return { data: `Successfully updated computer ${resourceId}` };
+	},
+	examplePayload: updateComputerExamplePayload
+});
+//#endregion
+//#region src/actions/computers/index.ts
+var computers_exports = /* @__PURE__ */ __exportAll({
+	getComputer: () => getComputer,
+	listComputers: () => listComputers,
+	updateComputer: () => updateComputer
+});
+//#endregion
+//#region src/actions/departments/createDepartment.ts
+const createDepartment = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Create Department",
+		description: "Create a new department."
+	},
+	inputs: createDepartmentInputs,
+	perform: async (context, { connection, departmentName }) => {
+		const { data } = await (await createClient(connection, context.debug.enabled)).post("/v1/departments", { name: departmentName });
+		return { data };
+	},
+	examplePayload: createDepartmentExamplePayload
+});
+//#endregion
+//#region src/actions/departments/deleteDepartment.ts
+const deleteDepartment = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Delete Department",
+		description: "Delete a department by ID."
+	},
+	inputs: deleteDepartmentInputs,
+	perform: async (context, { connection, resourceId }) => {
+		await (await createClient(connection, context.debug.enabled)).delete(`/v1/departments/${resourceId}`);
+		return { data: `Successfully deleted department ${resourceId}` };
+	},
+	examplePayload: deleteDepartmentExamplePayload
+});
+//#endregion
+//#region src/actions/departments/getDepartment.ts
+const getDepartment = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Get Department",
+		description: "Get a single department by ID."
+	},
+	inputs: getDepartmentInputs,
+	perform: async (context, { connection, resourceId }) => {
+		const { data } = await (await createClient(connection, context.debug.enabled)).get(`/v1/departments/${resourceId}`);
+		return { data };
+	},
+	examplePayload: getDepartmentExamplePayload
+});
+//#endregion
+//#region src/actions/departments/listDepartments.ts
+const listDepartments = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "List Departments",
+		description: "List all departments with optional filtering and pagination."
+	},
+	inputs: listDepartmentsInputs,
+	perform: async (context, { connection, pagination, sort, filter, fetchAll }) => {
+		return { data: await paginateResults(await createClient(connection, context.debug.enabled), "/v1/departments", fetchAll, {
+			page: pagination.page,
+			"page-size": pagination.pageSize,
+			sort,
+			filter
+		}) };
+	},
+	examplePayload: listDepartmentsExamplePayload
+});
+//#endregion
+//#region src/actions/departments/updateDepartment.ts
+const updateDepartment = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Update Department",
+		description: "Update an existing department."
+	},
+	inputs: updateDepartmentInputs,
+	perform: async (context, { connection, resourceId, departmentName }) => {
+		const { data } = await (await createClient(connection, context.debug.enabled)).put(`/v1/departments/${resourceId}`, { name: departmentName });
+		return { data };
+	},
+	examplePayload: updateDepartmentExamplePayload
+});
+//#endregion
+//#region src/actions/departments/index.ts
+var departments_exports = /* @__PURE__ */ __exportAll({
+	createDepartment: () => createDepartment,
+	deleteDepartment: () => deleteDepartment,
+	getDepartment: () => getDepartment,
+	listDepartments: () => listDepartments,
+	updateDepartment: () => updateDepartment
+});
+//#endregion
+//#region src/actions/misc/rawRequest.ts
+const rawRequest = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Raw Request",
+		description: "Send a raw HTTP request to the Jamf Pro API or the Classic API."
+	},
+	inputs: rawRequestInputs,
+	perform: async (context, { connection, apiType, ...httpInputs }) => {
+		const client = await createClient(connection, context.debug.enabled);
+		const { data } = await (0, _prismatic_io_spectral_http.sendRawRequest)(`${getBaseUrl(connection)}/${apiType}`, {
+			...httpInputs,
+			debugRequest: context.debug.enabled
+		}, client.defaults?.headers ?? {});
+		return { data };
+	}
+});
+//#endregion
+//#region src/actions/misc/index.ts
+var misc_exports = /* @__PURE__ */ __exportAll({ rawRequest: () => rawRequest });
+//#endregion
+//#region src/actions/mobileDevices/getMobileDevice.ts
+const getMobileDevice = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Get Mobile Device",
+		description: "Get a single mobile device record by ID."
+	},
+	inputs: getMobileDeviceInputs,
+	perform: async (context, { connection, resourceId }) => {
+		const { data } = await (await createClient(connection, context.debug.enabled)).get(`/v2/mobile-devices/${resourceId}`);
+		return { data };
+	},
+	examplePayload: getMobileDeviceExamplePayload
+});
+//#endregion
+//#region src/actions/mobileDevices/listMobileDevices.ts
+const listMobileDevices = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "List Mobile Devices",
+		description: "List mobile device inventory records with optional filtering and pagination."
+	},
+	inputs: listMobileDevicesInputs,
+	perform: async (context, { connection, pagination, sort, filter, section, fetchAll }) => {
+		return { data: await paginateResults(await createClient(connection, context.debug.enabled), "/v2/mobile-devices/detail", fetchAll, {
+			page: pagination.page,
+			"page-size": pagination.pageSize,
+			sort,
+			filter,
+			section
+		}) };
+	},
+	examplePayload: listMobileDevicesExamplePayload
+});
+//#endregion
+//#region src/actions/mobileDevices/index.ts
+var mobileDevices_exports = /* @__PURE__ */ __exportAll({
+	getMobileDevice: () => getMobileDevice,
+	listMobileDevices: () => listMobileDevices
+});
+//#endregion
+//#region src/actions/packages/createPackage.ts
+const createPackage = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Create Package",
+		description: "Create a new package record in Jamf Pro."
+	},
+	inputs: createPackageInputs,
+	perform: async (context, { connection, packageName, packageFileName, packageCategoryId, additionalFields }) => {
+		const { packagePriority, packageInfo, packageNotes, packageRebootRequired, packageOsInstall, packageFillUserTemplate, packageSuppressUpdates, packageSuppressEula, packageSuppressFromDock, packageSuppressRegistration } = additionalFields;
+		const client = await createClient(connection, context.debug.enabled);
+		const body = {
+			packageName,
+			fileName: packageFileName,
+			categoryId: packageCategoryId ?? "-1",
+			priority: packagePriority ? packagePriority : 10,
+			rebootRequired: packageRebootRequired,
+			osInstall: packageOsInstall,
+			fillUserTemplate: packageFillUserTemplate,
+			suppressUpdates: packageSuppressUpdates,
+			suppressEula: packageSuppressEula,
+			suppressFromDock: packageSuppressFromDock,
+			suppressRegistration: packageSuppressRegistration,
+			info: packageInfo,
+			notes: packageNotes
+		};
+		const { data } = await client.post("/v1/packages", body);
+		return { data };
+	},
+	examplePayload: createPackageExamplePayload
+});
+//#endregion
+//#region src/actions/packages/deletePackage.ts
+const deletePackage = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Delete Package",
+		description: "Delete a package record by ID."
+	},
+	inputs: deletePackageInputs,
+	perform: async (context, { connection, resourceId }) => {
+		await (await createClient(connection, context.debug.enabled)).delete(`/v1/packages/${resourceId}`);
+		return { data: `Successfully deleted package ${resourceId}` };
+	},
+	examplePayload: deletePackageExamplePayload
+});
+//#endregion
+//#region src/actions/packages/getPackage.ts
+const getPackage = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Get Package",
+		description: "Get a single package record by ID."
+	},
+	inputs: getPackageInputs,
+	perform: async (context, { connection, resourceId }) => {
+		const { data } = await (await createClient(connection, context.debug.enabled)).get(`/v1/packages/${resourceId}`);
+		return { data };
+	},
+	examplePayload: getPackageExamplePayload
+});
+//#endregion
+//#region src/actions/packages/listPackages.ts
+const listPackages = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "List Packages",
+		description: "List all packages with optional filtering and pagination."
+	},
+	inputs: listPackagesInputs,
+	perform: async (context, { connection, pagination, sort, filter, fetchAll }) => {
+		return { data: await paginateResults(await createClient(connection, context.debug.enabled), "/v1/packages", fetchAll, {
+			page: pagination.page,
+			"page-size": pagination.pageSize,
+			sort,
+			filter
+		}) };
+	},
+	examplePayload: listPackagesExamplePayload
+});
+//#endregion
+//#region src/actions/packages/updatePackage.ts
+const updatePackage = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Update Package",
+		description: "Update an existing package record."
+	},
+	inputs: updatePackageInputs,
+	perform: async (context, { connection, resourceId, packageCategoryId, additionalFields }) => {
+		const { packageName, packageFileName, packagePriority, packageInfo, packageNotes, packageRebootRequired, packageOsInstall, packageFillUserTemplate, packageSuppressUpdates, packageSuppressEula, packageSuppressFromDock, packageSuppressRegistration } = additionalFields;
+		const client = await createClient(connection, context.debug.enabled);
+		const { data: existing } = await client.get(`/v1/packages/${resourceId}`);
+		const body = mergeDefined(existing, {
+			packageName,
+			fileName: packageFileName,
+			categoryId: packageCategoryId,
+			priority: packagePriority,
+			rebootRequired: packageRebootRequired,
+			osInstall: packageOsInstall,
+			fillUserTemplate: packageFillUserTemplate,
+			suppressUpdates: packageSuppressUpdates,
+			suppressEula: packageSuppressEula,
+			suppressFromDock: packageSuppressFromDock,
+			suppressRegistration: packageSuppressRegistration,
+			info: packageInfo,
+			notes: packageNotes
+		});
+		const { data } = await client.put(`/v1/packages/${resourceId}`, body);
+		return { data };
+	},
+	examplePayload: updatePackageExamplePayload
+});
+//#endregion
+//#region src/actions/packages/index.ts
+var packages_exports = /* @__PURE__ */ __exportAll({
+	createPackage: () => createPackage,
+	deletePackage: () => deletePackage,
+	getPackage: () => getPackage,
+	listPackages: () => listPackages,
+	updatePackage: () => updatePackage
+});
+//#endregion
+//#region src/actions/scripts/createScript.ts
+const createScript = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Create Script",
+		description: "Create a new script."
+	},
+	inputs: createScriptInputs,
+	perform: async (context, { connection, scriptName, scriptCategoryId, additionalFields }) => {
+		const { scriptContents, scriptPriority, scriptInfo, scriptNotes } = additionalFields;
+		const client = await createClient(connection, context.debug.enabled);
+		const body = {
+			name: scriptName,
+			scriptContents,
+			categoryId: scriptCategoryId,
+			priority: scriptPriority,
+			info: scriptInfo,
+			notes: scriptNotes
+		};
+		const { data } = await client.post("/v1/scripts", body);
+		return { data };
+	},
+	examplePayload: createScriptExamplePayload
+});
+//#endregion
+//#region src/actions/scripts/deleteScript.ts
+const deleteScript = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Delete Script",
+		description: "Delete a script by ID."
+	},
+	inputs: deleteScriptInputs,
+	perform: async (context, { connection, resourceId }) => {
+		await (await createClient(connection, context.debug.enabled)).delete(`/v1/scripts/${resourceId}`);
+		return { data: `Successfully deleted script ${resourceId}` };
+	},
+	examplePayload: deleteScriptExamplePayload
+});
+//#endregion
+//#region src/actions/scripts/getScript.ts
+const getScript = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Get Script",
+		description: "Get a single script by ID."
+	},
+	inputs: getScriptInputs,
+	perform: async (context, { connection, resourceId }) => {
+		const { data } = await (await createClient(connection, context.debug.enabled)).get(`/v1/scripts/${resourceId}`);
+		return { data };
+	},
+	examplePayload: getScriptExamplePayload
+});
+//#endregion
+//#region src/actions/scripts/listScripts.ts
+const listScripts = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "List Scripts",
+		description: "List all scripts with optional filtering and pagination."
+	},
+	inputs: listScriptsInputs,
+	perform: async (context, { connection, pagination, sort, filter, fetchAll }) => {
+		return { data: await paginateResults(await createClient(connection, context.debug.enabled), "/v1/scripts", fetchAll, {
+			page: pagination.page,
+			"page-size": pagination.pageSize,
+			sort,
+			filter
+		}) };
+	},
+	examplePayload: listScriptsExamplePayload
+});
+//#endregion
+//#region src/actions/scripts/updateScript.ts
+const updateScript = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Update Script",
+		description: "Update an existing script."
+	},
+	inputs: updateScriptInputs,
+	perform: async (context, { connection, resourceId, scriptCategoryId, additionalFields }) => {
+		const { scriptName, scriptContents, scriptPriority, scriptInfo, scriptNotes } = additionalFields;
+		const client = await createClient(connection, context.debug.enabled);
+		const { data: existing } = await client.get(`/v1/scripts/${resourceId}`);
+		const body = mergeDefined(existing, {
+			name: scriptName,
+			scriptContents,
+			categoryId: scriptCategoryId,
+			priority: scriptPriority,
+			info: scriptInfo,
+			notes: scriptNotes
+		});
+		const { data } = await client.put(`/v1/scripts/${resourceId}`, body);
+		return { data };
+	},
+	examplePayload: updateScriptExamplePayload
+});
+//#endregion
+//#region src/actions/scripts/index.ts
+var scripts_exports = /* @__PURE__ */ __exportAll({
+	createScript: () => createScript,
+	deleteScript: () => deleteScript,
+	getScript: () => getScript,
+	listScripts: () => listScripts,
+	updateScript: () => updateScript
+});
+//#endregion
+//#region src/actions/users/listUsers.ts
+const listUsers = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "List Users",
+		description: "List Jamf Pro user accounts with optional filtering and pagination."
+	},
+	inputs: listUsersInputs,
+	perform: async (context, { connection, pagination, sort, filter, fetchAll }) => {
+		return { data: await paginateResults(await createClient(connection, context.debug.enabled), "/v1/users", fetchAll, {
+			page: pagination.page,
+			"page-size": pagination.pageSize,
+			sort,
+			filter
+		}) };
+	},
+	examplePayload: listUsersExamplePayload
+});
+//#endregion
+//#region src/actions/users/index.ts
+var users_exports = /* @__PURE__ */ __exportAll({ listUsers: () => listUsers });
+//#endregion
+//#region src/actions/webhooks/createWebhook.ts
+const createWebhook = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Create Webhook",
+		description: "Create a new webhook subscription in Jamf Pro."
+	},
+	inputs: createWebhookInputs,
+	perform: async (context, { connection, webhookName, webhookEvent, webhookUrl, additionalFields }) => {
+		const { webhookContentType, webhookEnabled, webhookAuthType, webhookAuthHeaderName, webhookAuthHeaderValue } = additionalFields;
+		const client = await createClassicClient(connection, context.debug.enabled);
+		let authFields = {};
+		if (webhookAuthType === "HEADER") {
+			if (!webhookAuthHeaderName || !webhookAuthHeaderValue) throw new Error("Header authentication requires both an Auth Header Name and an Auth Header Value.");
+			authFields = {
+				authentication_type: "HEADER",
+				header: JSON.stringify({ [webhookAuthHeaderName]: webhookAuthHeaderValue })
+			};
+		}
+		const body = toWebhookXml({
+			name: webhookName,
+			event: webhookEvent,
+			url: webhookUrl,
+			content_type: webhookContentType,
+			enabled: webhookEnabled,
+			...authFields
+		});
+		const { data } = await client.post("/webhooks/id/0", body, { headers: { "Content-Type": "application/xml" } });
+		return { data: { id: parseWebhookId(data) ?? null } };
+	},
+	examplePayload: createWebhookExamplePayload
+});
+//#endregion
+//#region src/actions/webhooks/deleteInstancedWebhooks.ts
+const deleteInstancedWebhooks = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Delete Instanced Webhooks",
+		description: "Delete all Jamf Pro webhooks that point to a flow in this instance."
+	},
+	inputs: deleteInstancedWebhooksInputs,
+	perform: async (context, { connection }) => {
+		const client = await createClassicClient(connection, context.debug.enabled);
+		const { data } = await client.get("/webhooks");
+		const webhooks = await Promise.all(data.webhooks.map(({ id }) => client.get(`/webhooks/id/${id}`).then((response) => response.data.webhook)));
+		const instanceUrls = Object.values(context.webhookUrls);
+		const toDelete = webhooks.filter((webhook) => instanceUrls.includes(webhook.url));
+		for (const webhook of toDelete) {
+			context.logger.info(`Deleting webhook ${webhook.id}...`);
+			await client.delete(`/webhooks/id/${webhook.id}`);
+		}
+		return { data: { webhooksDeleted: toDelete.length } };
+	},
+	examplePayload: deleteInstancedWebhooksExamplePayload
+});
+//#endregion
+//#region src/actions/webhooks/deleteWebhook.ts
+const deleteWebhook = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Delete Webhook",
+		description: "Delete a webhook subscription by ID."
+	},
+	inputs: deleteWebhookInputs,
+	perform: async (context, { connection, resourceId }) => {
+		await (await createClassicClient(connection, context.debug.enabled)).delete(`/webhooks/id/${resourceId}`);
+		return { data: `Successfully deleted webhook ${resourceId}` };
+	},
+	examplePayload: deleteWebhookExamplePayload
+});
+//#endregion
+//#region src/actions/webhooks/getWebhook.ts
+const getWebhook = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Get Webhook",
+		description: "Get a single webhook subscription by ID."
+	},
+	inputs: getWebhookInputs,
+	perform: async (context, { connection, resourceId }) => {
+		const { data } = await (await createClassicClient(connection, context.debug.enabled)).get(`/webhooks/id/${resourceId}`);
+		return { data };
+	},
+	examplePayload: getWebhookExamplePayload
+});
+//#endregion
+//#region src/actions/webhooks/listWebhooks.ts
+const listWebhooks = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "List Webhooks",
+		description: "List all webhook subscriptions configured in Jamf Pro."
+	},
+	inputs: listWebhooksInputs,
+	perform: async (context, { connection }) => {
+		const { data } = await (await createClassicClient(connection, context.debug.enabled)).get("/webhooks");
+		return { data };
+	},
+	examplePayload: listWebhooksExamplePayload
+});
+//#endregion
+//#region src/actions/webhooks/updateWebhook.ts
+const updateWebhook = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Update Webhook",
+		description: "Update an existing webhook subscription."
+	},
+	inputs: updateWebhookInputs,
+	perform: async (context, { connection, resourceId, additionalFields }) => {
+		const { webhookName, webhookEvent, webhookUrl, webhookContentType, webhookEnabled } = additionalFields;
+		const client = await createClassicClient(connection, context.debug.enabled);
+		const body = toWebhookXml({
+			name: webhookName,
+			event: webhookEvent,
+			url: webhookUrl,
+			content_type: webhookContentType,
+			enabled: webhookEnabled
+		});
+		await client.put(`/webhooks/id/${resourceId}`, body, { headers: { "Content-Type": "application/xml" } });
+		return { data: { id: Number(resourceId) } };
+	},
+	examplePayload: updateWebhookExamplePayload
+});
+//#endregion
+//#region src/actions/webhooks/index.ts
+var webhooks_exports = /* @__PURE__ */ __exportAll({
+	createWebhook: () => createWebhook,
+	deleteInstancedWebhooks: () => deleteInstancedWebhooks,
+	deleteWebhook: () => deleteWebhook,
+	getWebhook: () => getWebhook,
+	listWebhooks: () => listWebhooks,
+	updateWebhook: () => updateWebhook
+});
+//#endregion
+//#region src/actions/index.ts
+var actions_default = {
+	...computers_exports,
+	...mobileDevices_exports,
+	...users_exports,
+	...departments_exports,
+	...categories_exports,
+	...scripts_exports,
+	...packages_exports,
+	...webhooks_exports,
+	...misc_exports
+};
+//#endregion
+//#region src/dataSources/selectCategory.ts
+const selectCategory = (0, _prismatic_io_spectral.dataSource)({
+	display: {
+		label: "Select Category",
+		description: "Dynamically fetch a list of categories from Jamf Pro for use in a dropdown."
+	},
+	dataSourceType: "picklist",
+	inputs: selectCategoryInputs,
+	perform: async (_context, { connection }) => {
+		const { results } = await paginateResults(await createClient(connection, false), "/v1/categories", true, {});
+		return { result: mapToSortedElements(results, "id", "name") };
+	},
+	examplePayload: selectCategoryExamplePayload
+});
+//#endregion
+//#region src/dataSources/selectComputer.ts
+const selectComputer = (0, _prismatic_io_spectral.dataSource)({
+	display: {
+		label: "Select Computer",
+		description: "Dynamically fetch a list of computers from Jamf Pro for use in a dropdown."
+	},
+	dataSourceType: "picklist",
+	inputs: selectComputerInputs,
+	perform: async (_context, { connection }) => {
+		const { results } = await paginateResults(await createClient(connection, false), "/v1/computers-inventory", true, { section: ["GENERAL"] });
+		return { result: mapToSortedElements(results, "id", (c) => c.general?.name) };
+	},
+	examplePayload: selectComputerExamplePayload
+});
+//#endregion
+//#region src/dataSources/selectDepartment.ts
+const selectDepartment = (0, _prismatic_io_spectral.dataSource)({
+	display: {
+		label: "Select Department",
+		description: "Dynamically fetch a list of departments from Jamf Pro for use in a dropdown."
+	},
+	dataSourceType: "picklist",
+	inputs: selectDepartmentInputs,
+	perform: async (_context, { connection }) => {
+		const { results } = await paginateResults(await createClient(connection, false), "/v1/departments", true, {});
+		return { result: mapToSortedElements(results, "id", "name") };
+	},
+	examplePayload: selectDepartmentExamplePayload
+});
+//#endregion
+//#region src/dataSources/index.ts
+var dataSources_default = {
+	selectComputer,
+	selectMobileDevice: (0, _prismatic_io_spectral.dataSource)({
+		display: {
+			label: "Select Mobile Device",
+			description: "Dynamically fetch a list of mobile devices from Jamf Pro for use in a dropdown."
+		},
+		dataSourceType: "picklist",
+		inputs: selectMobileDeviceInputs,
+		perform: async (_context, { connection }) => {
+			const { results } = await paginateResults(await createClient(connection, false), "/v2/mobile-devices", true, {});
+			return { result: mapToSortedElements(results, "id", "name") };
+		},
+		examplePayload: selectMobileDeviceExamplePayload
+	}),
+	selectDepartment,
+	selectCategory,
+	selectPackage: (0, _prismatic_io_spectral.dataSource)({
+		display: {
+			label: "Select Package",
+			description: "Dynamically fetch a list of packages from Jamf Pro for use in a dropdown."
+		},
+		dataSourceType: "picklist",
+		inputs: selectPackageInputs,
+		perform: async (_context, { connection }) => {
+			const { results } = await paginateResults(await createClient(connection, false), "/v1/packages", true, {});
+			return { result: mapToSortedElements(results, "id", "packageName") };
+		},
+		examplePayload: selectPackageExamplePayload
+	}),
+	selectScript: (0, _prismatic_io_spectral.dataSource)({
+		display: {
+			label: "Select Script",
+			description: "Dynamically fetch a list of scripts from Jamf Pro for use in a dropdown."
+		},
+		dataSourceType: "picklist",
+		inputs: selectScriptInputs,
+		perform: async (_context, { connection }) => {
+			const { results } = await paginateResults(await createClient(connection, false), "/v1/scripts", true, {});
+			return { result: mapToSortedElements(results, "id", "name") };
+		},
+		examplePayload: selectScriptExamplePayload
+	}),
+	selectWebhook: (0, _prismatic_io_spectral.dataSource)({
+		display: {
+			label: "Select Webhook",
+			description: "Dynamically fetch a list of webhooks from Jamf Pro for use in a dropdown."
+		},
+		dataSourceType: "picklist",
+		inputs: selectWebhookInputs,
+		perform: async (_context, { connection }) => {
+			const { data } = await (await createClassicClient(connection, false)).get("/webhooks");
+			return { result: mapToSortedElements(data.webhooks, "id", "name") };
+		},
+		examplePayload: selectWebhookExamplePayload
+	})
+};
+//#endregion
+//#region src/triggers/pollNewComputers.ts
+const pollNewComputers = (0, _prismatic_io_spectral.pollingTrigger)({
+	display: {
+		label: "New Computers",
+		description: "Retrieves existing and newly enrolled computers in Jamf Pro. Load history once, check for new enrollments on a schedule, or both."
+	},
+	inputs: pollComputersInputs,
+	triggerResolverSupport: "valid",
+	batchConfig: { batchSize: 50 },
+	triggerResolver: {
+		resolveItems: (_context, { payload }) => resolveNewComputerChanges(payload.body.data),
+		getNextPaginationState: (_context, { payload }) => payload.paginationState ?? null
+	},
+	perform: async (context, payload, { connection, lookBackDate }) => {
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const state = context.polling.getState() ?? {};
+		const incoming = payload.paginationState;
+		const seed = lookBackDate || now;
+		const result = await drainWatermark(fetchComputerPage(await createClient(connection, context.debug.enabled)), resolveStartCursor(state, incoming, seed), resolveSafeHorizon(now), context.batch?.enabled === true ? 1 : 20);
+		context.polling.setState(nextPollingState(state, seed, result));
+		context.logger.debug(`Polled ${result.delivered.length} computers, drained=${result.drained}`);
+		return {
+			payload: {
+				...payload,
+				paginationState: result.drained ? void 0 : result.cursor,
+				body: { data: result.delivered }
+			},
+			polledNoChanges: result.drained && !incoming && result.delivered.length === 0
+		};
+	}
+});
+//#endregion
+//#region src/triggers/pollNewMobileDevices.ts
+const pollNewMobileDevices = (0, _prismatic_io_spectral.pollingTrigger)({
+	display: {
+		label: "New Mobile Devices",
+		description: "Checks for newly enrolled mobile devices in Jamf Pro on a configured schedule."
+	},
+	inputs: pollMobileDevicesInputs,
+	perform: async (context, payload, { connection }) => {
+		const pollState = context.polling.getState();
+		const lastMaxId = pollState.lastMaxId ?? 0;
+		const isFirstRun = pollState.lastMaxId === void 0;
+		context.logger.debug(`Polling for new mobile devices. Last known max ID: ${lastMaxId}`);
+		const { results: allDevices } = await paginateResults(await createClient(connection, context.debug.enabled), "/v2/mobile-devices", true, {});
+		const newMaxId = allDevices.reduce((max, d) => Math.max(max, _prismatic_io_spectral.util.types.toInt(d.id, 10) || 0), lastMaxId);
+		context.polling.setState({ lastMaxId: newMaxId });
+		if (isFirstRun) {
+			context.logger.debug(`First run — established baseline of ${allDevices.length} devices. Max ID: ${newMaxId}`);
+			return {
+				payload: {
+					...payload,
+					body: { data: [] }
+				},
+				polledNoChanges: true
+			};
+		}
+		const newDevices = allDevices.filter((d) => (_prismatic_io_spectral.util.types.toInt(d.id, 10) || 0) > lastMaxId);
+		context.logger.debug(`Found ${newDevices.length} newly enrolled mobile devices`);
+		return {
+			payload: {
+				...payload,
+				body: { data: newDevices }
+			},
+			polledNoChanges: newDevices.length === 0
+		};
+	}
+});
+//#endregion
+//#region src/triggers/index.ts
+var triggers_default = {
+	webhook: (0, _prismatic_io_spectral.trigger)({
+		display: {
+			label: "Manual Webhook",
+			description: "Receive and validate webhook requests from Jamf Pro for manually configured webhook subscriptions."
+		},
+		inputs: webhookInputs,
+		perform: async (context, payload, { authHeaderName, authHeaderValue }) => {
+			if (!context.isSimulatedTestExecution && authHeaderName && authHeaderValue) {
+				if (_prismatic_io_spectral.util.types.lowerCaseHeaders(payload.headers)[authHeaderName.toLowerCase()] !== authHeaderValue) throw new Error("Jamf webhook header authentication failed: missing or invalid auth header.");
+			}
+			return { payload };
+		},
+		scheduleSupport: "invalid",
+		synchronousResponseSupport: "valid",
+		examplePayload: webhookExamplePayload
+	}),
+	webhookEvents: (0, _prismatic_io_spectral.trigger)({
+		display: {
+			label: "Webhook Events",
+			description: "Subscribe to Jamf Pro events. On deploy, this trigger creates a webhook in Jamf Pro for each selected event (secured with a generated authentication header) and removes them when the instance is deleted. Incoming requests are validated against that header."
+		},
+		inputs: webhookEventsInputs,
+		perform: async (context, payload) => {
+			if (!context.isSimulatedTestExecution) {
+				const state = context.crossFlowState[getStoreKey(context.flow.stableId)];
+				const headers = _prismatic_io_spectral.util.types.lowerCaseHeaders(payload.headers);
+				if (!state?.webhookAuthValue || headers["X-Jamf-Signature".toLowerCase()] !== state.webhookAuthValue) throw new Error("Jamf webhook header authentication failed: missing or invalid auth header.");
+			}
+			return Promise.resolve({ payload });
+		},
+		scheduleSupport: "invalid",
+		synchronousResponseSupport: "invalid",
+		examplePayload: webhookExamplePayload,
+		webhookLifecycleHandlers: {
+			create: createManagedWebhooks,
+			delete: deleteManagedWebhooks
+		}
+	}),
+	pollNewComputers,
+	pollNewMobileDevices
+};
+//#endregion
+//#region src/index.ts
+var src_default = (0, _prismatic_io_spectral.component)({
+	key: "jamf",
+	public: true,
+	documentationUrl: "https://prismatic.io/docs/components/jamf/",
+	display: {
+		label: "Jamf",
+		description: "Manage Apple devices, policies, scripts, and users with Jamf Pro and Jamf School.",
+		iconPath: "icon.png",
+		category: "Application Connectors"
+	},
+	hooks: { error: _prismatic_io_spectral_http.handleErrors },
+	actions: actions_default,
+	connections: connections_default,
+	triggers: triggers_default,
+	dataSources: dataSources_default
+});
+//#endregion
+//#region npm-dist/.entry.ts
+var _entry_default = (0, _prismatic_io_spectral.callableComponent)(src_default);
+//#endregion
+module.exports = _entry_default;