@tangle-network/agent-integrations 0.73.0 → 0.74.0

package/dist/cloudbeds-BL5EF3xl.js

@@ -0,0 +1,1195 @@
+import { i as ProviderRateLimited, t as CredentialsExpired } from "./types-BSDXGSi5.js";
+import { n as record, r as requestJson, t as ProviderProtocolError } from "./response-json-BnUINkTL.js";
+import { createHmac, timingSafeEqual } from "node:crypto";
+//#region src/connectors/webhooks.ts
+/**
+* Inbound webhook signature verifiers — provider-specific HMAC schemes.
+*
+* Each signature scheme is a pure function:
+*   (rawBody: string, headers, secret, now?) → boolean
+*
+* Constant-time comparison via `crypto.timingSafeEqual`. Timestamps are
+* checked against a configurable tolerance to bound replay risk; the default
+* mirrors the upstream provider's documented window (Stripe: 5 min, Slack: 5 min).
+*
+* These verifiers are the building blocks for any inbound-webhook receiver
+* (a route + a `verify` call + a per-event handler). They live in this
+* package so every consumer of the integration substrate gets correct
+* verification — not just one product reimplementing it.
+*/
+/** Default replay-protection window. Providers commonly use 5 minutes. */
+const DEFAULT_SIGNATURE_TOLERANCE_SECONDS = 300;
+function parseStripeSignatureHeader(header) {
+	const acc = { sigs: [] };
+	for (const part of header.split(",")) {
+		const idx = part.indexOf("=");
+		if (idx < 0) continue;
+		const key = part.slice(0, idx).trim();
+		const val = part.slice(idx + 1).trim();
+		if (key === "t") {
+			const n = Number(val);
+			if (Number.isFinite(n)) acc.ts = n;
+		} else if (key === "v1") acc.sigs.push(val);
+	}
+	if (acc.ts === void 0 || acc.sigs.length === 0) return null;
+	return {
+		t: acc.ts,
+		sigs: acc.sigs
+	};
+}
+/** Verify a Stripe webhook signature against the raw request body. */
+function verifyStripeSignature(rawBody, signatureHeader, secret, options = {}) {
+	const parsed = parseStripeSignatureHeader(signatureHeader);
+	if (!parsed) return false;
+	const tolerance = options.toleranceSeconds ?? 300;
+	const now = options.now ?? Math.floor(Date.now() / 1e3);
+	if (Math.abs(now - parsed.t) > tolerance) return false;
+	const expected = createHmac("sha256", secret).update(`${parsed.t}.${rawBody}`).digest("hex");
+	const expectedBuf = Buffer.from(expected, "utf8");
+	for (const sig of parsed.sigs) {
+		const sigBuf = Buffer.from(sig, "utf8");
+		if (sigBuf.length !== expectedBuf.length) continue;
+		if (timingSafeEqual(sigBuf, expectedBuf)) return true;
+	}
+	return false;
+}
+function verifySlackSignature(rawBody, signatureHeader, timestampHeader, secret, options = {}) {
+	if (!signatureHeader.startsWith("v0=")) return false;
+	const ts = Number(timestampHeader);
+	if (!Number.isFinite(ts)) return false;
+	const tolerance = options.toleranceSeconds ?? 300;
+	const now = options.now ?? Math.floor(Date.now() / 1e3);
+	if (Math.abs(now - ts) > tolerance) return false;
+	const expected = "v0=" + createHmac("sha256", secret).update(`v0:${ts}:${rawBody}`).digest("hex");
+	const expectedBuf = Buffer.from(expected, "utf8");
+	const sigBuf = Buffer.from(signatureHeader, "utf8");
+	if (sigBuf.length !== expectedBuf.length) return false;
+	return timingSafeEqual(sigBuf, expectedBuf);
+}
+function verifyHmacSignature(rawBody, signatureHeader, secret, options = {}) {
+	const algorithm = options.algorithm ?? "sha256";
+	const prefix = options.signaturePrefix ?? "";
+	const lower = options.lowercaseHex ?? true;
+	let candidate = signatureHeader;
+	if (prefix) {
+		if (!candidate.startsWith(prefix)) return false;
+		candidate = candidate.slice(prefix.length);
+	}
+	if (lower) candidate = candidate.toLowerCase();
+	const expected = createHmac(algorithm, secret).update(rawBody).digest("hex");
+	const expectedBuf = Buffer.from(expected, "utf8");
+	const sigBuf = Buffer.from(candidate, "utf8");
+	if (sigBuf.length !== expectedBuf.length) return false;
+	return timingSafeEqual(sigBuf, expectedBuf);
+}
+/** Verify a Twilio webhook signature. */
+function verifyTwilioSignature(input, options = {}) {
+	if (!input.authToken) return options.skipWhenAuthTokenMissing === true;
+	const signature = input.signatureHeader;
+	if (!signature || Array.isArray(signature)) return false;
+	if (!input.fullUrl) return false;
+	const data = options.bodyAsRaw === true ? input.fullUrl + (options.rawBody ?? "") : Object.keys(input.params ?? {}).sort().reduce((acc, key) => acc + key + (input.params[key] ?? ""), input.fullUrl);
+	const expected = createHmac("sha1", input.authToken).update(data).digest("base64");
+	const expectedBuf = Buffer.from(expected);
+	const sigBuf = Buffer.from(signature);
+	if (expectedBuf.length !== sigBuf.length) return false;
+	return timingSafeEqual(expectedBuf, sigBuf);
+}
+/** Verify a Tangle inbound-email signature against the raw request body. */
+function verifyEmailSignature(rawBody, signatureHeader, timestampHeader, secret, options = {}) {
+	const ts = Number(timestampHeader);
+	if (!Number.isFinite(ts)) return false;
+	const tolerance = options.toleranceSeconds ?? 300;
+	const now = options.now ?? Math.floor(Date.now() / 1e3);
+	if (Math.abs(now - ts) > tolerance) return false;
+	const expected = createHmac("sha256", secret).update(`${ts}.${rawBody}`).digest("hex");
+	const expectedBuf = Buffer.from(expected, "utf8");
+	const sigBuf = Buffer.from(signatureHeader.toLowerCase(), "utf8");
+	if (sigBuf.length !== expectedBuf.length) return false;
+	return timingSafeEqual(sigBuf, expectedBuf);
+}
+function firstHeader(headers, name) {
+	const v = headers[name] ?? headers[name.toLowerCase()] ?? Object.entries(headers).find(([key]) => key.toLowerCase() === name.toLowerCase())?.[1];
+	if (Array.isArray(v)) return v[0];
+	return typeof v === "string" ? v : void 0;
+}
+//#endregion
+//#region src/connectors/adapters/cloudbeds.ts
+const API = "https://api.cloudbeds.com/api/v1.3";
+const DATE = /^\d{4}-\d{2}-\d{2}$/;
+const PROPERTY_ID = /^[1-9]\d{0,19}$/;
+const OPERATION_ID = /^[A-Za-z0-9:._-]{1,128}$/;
+const PROVIDER_ID = /^[A-Za-z0-9_-]{1,64}$/;
+const HEADER_NAME = /^[A-Za-z0-9!#$%&'*+.^_`|~-]{1,64}$/;
+const STATUSES = /* @__PURE__ */ new Set([
+	"not_confirmed",
+	"confirmed",
+	"canceled",
+	"checked_in",
+	"checked_out",
+	"no_show"
+]);
+const ROOM_CONDITIONS = /* @__PURE__ */ new Set(["clean", "dirty"]);
+const REPORTED_ROOM_CONDITIONS = /* @__PURE__ */ new Set([
+	"clean",
+	"dirty",
+	"inspected"
+]);
+const FRONTDESK_STATUSES = /* @__PURE__ */ new Set([
+	"check-in",
+	"check-out",
+	"stayover",
+	"turnover",
+	"unused"
+]);
+/**
+* Webhook events the connector subscribes to and the Cloudbeds webhook provider
+* parses. All five are `read:reservation` events in the Cloudbeds webhook guide.
+* `reservation/status_changed` carries created-to-confirmed, `canceled`,
+* `checked_in`, and `checked_out` transitions.
+*/
+const CLOUDBEDS_WEBHOOK_EVENTS = [
+	{
+		object: "reservation",
+		action: "created"
+	},
+	{
+		object: "reservation",
+		action: "status_changed"
+	},
+	{
+		object: "reservation",
+		action: "dates_changed"
+	},
+	{
+		object: "reservation",
+		action: "accommodation_changed"
+	},
+	{
+		object: "reservation",
+		action: "deleted"
+	}
+];
+function boundedString(value, name, max = 256) {
+	if (typeof value !== "string" || !value.trim() || value.length > max || /[\u0000-\u001f\u007f]/.test(value)) throw new Error(`cloudbeds: invalid ${name}`);
+	return value;
+}
+function providerId(value, name) {
+	if (typeof value !== "string" || !PROVIDER_ID.test(value)) throw new Error(`cloudbeds: invalid ${name}`);
+	return value;
+}
+function providerText(value, max = 256) {
+	return typeof value === "string" && value.length <= max && !/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/.test(value) && (max > 256 || !/[\n\r\t]/.test(value)) ? value : null;
+}
+function providerNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function providerCount(value) {
+	const parsed = typeof value === "string" && /^\d{1,4}$/.test(value) ? Number(value) : value;
+	return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : null;
+}
+function malformed(what) {
+	throw new ProviderProtocolError(`Cloudbeds returned malformed ${what}`, "invalid_response");
+}
+function propertyId(source) {
+	const value = source.metadata.propertyId;
+	if (typeof value !== "string" || !PROPERTY_ID.test(value)) throw new Error("cloudbeds: connection requires one numeric propertyId");
+	return value;
+}
+function apiKey(source) {
+	const value = source.credentials;
+	if (value.kind !== "api-key" || !value.apiKey || /[\u0000- \u007f]/.test(value.apiKey)) throw new Error("cloudbeds: connection requires an API key");
+	return value.apiKey;
+}
+async function call(source, path, init) {
+	const headers = {
+		"x-api-key": apiKey(source),
+		accept: "application/json",
+		...init.headers
+	};
+	let result;
+	try {
+		result = await requestJson(`${API}/${path}`, {
+			...init,
+			headers
+		}, { maxResponseBytes: 2e6 });
+	} catch (error) {
+		if (error instanceof ProviderProtocolError && error.status === 401) throw new CredentialsExpired("Cloudbeds rejected the API key", source.id);
+		if (error instanceof ProviderProtocolError && error.status === 429) throw new ProviderRateLimited("Cloudbeds rate limit (429)", source.id, {
+			status: 429,
+			retryAfterMs: error.retryAfterMs
+		});
+		throw error;
+	}
+	if (record(result) && result.success === false) throw new ProviderProtocolError("Cloudbeds rejected the request", "provider_rejected", 422, true);
+	if (!record(result) || result.success !== true) throw new ProviderProtocolError("Cloudbeds returned an unsuccessful or malformed response", "invalid_response");
+	return result;
+}
+const form = (body) => ({
+	method: "POST",
+	headers: { "content-type": "application/x-www-form-urlencoded" },
+	body: body.toString()
+});
+function date(value, label) {
+	if (typeof value !== "string" || !DATE.test(value) || Number.isNaN(Date.parse(`${value}T00:00:00Z`)) || (/* @__PURE__ */ new Date(`${value}T00:00:00Z`)).toISOString().slice(0, 10) !== value) throw new Error(`cloudbeds: invalid ${label}`);
+	return value;
+}
+function providerDate(value) {
+	try {
+		return date(value, "provider date");
+	} catch {
+		throw new ProviderProtocolError("Cloudbeds returned an invalid reservation date", "invalid_response");
+	}
+}
+function nights(startDate, endDate) {
+	return (Date.parse(`${endDate}T00:00:00Z`) - Date.parse(`${startDate}T00:00:00Z`)) / 864e5;
+}
+function page(value, label, fallback, max) {
+	const selected = value ?? fallback;
+	if (!Number.isSafeInteger(selected) || selected < 1 || selected > max) throw new Error(`cloudbeds: invalid ${label}`);
+	return selected;
+}
+function money(value, label, allowZero = false) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value < (allowZero ? 0 : .01) || value > 1e6 || Math.abs(value * 100 - Math.round(value * 100)) > 1e-7) throw new Error(`cloudbeds: invalid ${label}`);
+	return value;
+}
+function pagination(result, pageSize, what) {
+	if (!Array.isArray(result.data) || !Number.isSafeInteger(result.count) || !Number.isSafeInteger(result.total) || result.count < 0 || result.total < 0 || result.count !== result.data.length || result.total < result.count || result.count > pageSize) malformed(`${what} pagination`);
+	return result.data;
+}
+function distinct(values) {
+	return [...new Set(values.filter((value) => value !== null))];
+}
+function reservationQuery(args, property) {
+	const query = new URLSearchParams({ propertyID: property });
+	const pairs = [["checkInFrom", "checkInTo"], ["checkOutFrom", "checkOutTo"]];
+	let found = false;
+	for (const [fromKey, toKey] of pairs) {
+		if (args[fromKey] === void 0 && args[toKey] === void 0) continue;
+		const from = date(args[fromKey], fromKey);
+		const to = date(args[toKey], toKey);
+		const days = nights(from, to);
+		if (days < 0 || days > 31) throw new Error("cloudbeds: reservation date range must be at most 31 days");
+		query.set(fromKey, from);
+		query.set(toKey, to);
+		found = true;
+	}
+	if (args.status !== void 0) {
+		if (typeof args.status !== "string" || !STATUSES.has(args.status)) throw new Error("cloudbeds: invalid status");
+		query.set("status", args.status);
+	}
+	if (!found && args.status !== "checked_in") throw new Error("cloudbeds: an arrival or departure date range is required unless status is checked_in");
+	query.set("includeAllRooms", "true");
+	query.set("pageNumber", String(page(args.pageNumber, "pageNumber", 1, 1e5)));
+	query.set("pageSize", String(page(args.pageSize, "pageSize", 100, 100)));
+	return query;
+}
+function reservationRooms(raw) {
+	if (raw === void 0 || raw === null) return {
+		roomTypeIds: [],
+		roomIds: [],
+		roomNames: []
+	};
+	if (!Array.isArray(raw)) malformed("reservation rooms");
+	const rooms = raw.map((room) => {
+		if (!record(room) || typeof room.roomTypeID !== "string" || !PROVIDER_ID.test(room.roomTypeID) || room.roomID !== void 0 && room.roomID !== null && (typeof room.roomID !== "string" || !PROVIDER_ID.test(room.roomID)) || room.roomName !== void 0 && room.roomName !== null && providerText(room.roomName) === null) malformed("reservation rooms");
+		return {
+			roomTypeId: room.roomTypeID,
+			roomId: typeof room.roomID === "string" ? room.roomID : null,
+			roomName: providerText(room.roomName)
+		};
+	});
+	return {
+		roomTypeIds: distinct(rooms.map((room) => room.roomTypeId)),
+		roomIds: distinct(rooms.map((room) => room.roomId)),
+		roomNames: distinct(rooms.map((room) => room.roomName))
+	};
+}
+function reservations(result, property, query) {
+	const pageSize = Number(query.get("pageSize"));
+	const items = pagination(result, pageSize, "reservation").map((raw) => {
+		if (!record(raw) || raw.propertyID !== property || typeof raw.reservationID !== "string" || !raw.reservationID || typeof raw.status !== "string" || !STATUSES.has(raw.status)) throw new ProviderProtocolError("Cloudbeds returned a reservation outside the connected property or with invalid fields", "invalid_response");
+		return {
+			propertyId: property,
+			reservationId: raw.reservationID,
+			status: raw.status,
+			arrivalDate: providerDate(raw.startDate),
+			departureDate: providerDate(raw.endDate),
+			guestId: typeof raw.guestID === "string" && PROVIDER_ID.test(raw.guestID) ? raw.guestID : null,
+			guestName: providerText(raw.guestName),
+			balance: providerNumber(raw.balance),
+			...reservationRooms(raw.rooms)
+		};
+	});
+	const pageNumber = Number(query.get("pageNumber"));
+	return {
+		reservations: items,
+		pageNumber,
+		pageSize,
+		total: result.total,
+		hasMore: pageNumber * pageSize < result.total
+	};
+}
+async function readReservation(source, property, reservationId) {
+	const result = await call(source, `getReservation?${new URLSearchParams({
+		propertyID: property,
+		reservationID: reservationId
+	})}`, { method: "GET" });
+	if (!record(result.data) || result.data.propertyID !== property || result.data.reservationID !== reservationId) throw new ProviderProtocolError("Cloudbeds could not verify the reservation belongs to the connected property", "invalid_response");
+	return result.data;
+}
+function reservationRoom(raw, assigned) {
+	if (!record(raw) || typeof raw.roomTypeID !== "string" || !PROVIDER_ID.test(raw.roomTypeID) || assigned && (typeof raw.roomID !== "string" || !PROVIDER_ID.test(raw.roomID))) malformed("reservation rooms");
+	return {
+		...assigned ? {
+			roomId: raw.roomID,
+			roomName: providerText(raw.roomName)
+		} : {},
+		roomTypeId: raw.roomTypeID,
+		roomTypeName: providerText(raw.roomTypeName),
+		startDate: providerDate(raw.startDate),
+		endDate: providerDate(raw.endDate),
+		adults: providerCount(raw.adults),
+		children: providerCount(raw.children)
+	};
+}
+function balanceDetailed(raw) {
+	const value = Array.isArray(raw) ? raw.length === 0 ? null : raw.length === 1 ? raw[0] : malformed("balance detail") : raw;
+	if (value === null || value === void 0) return null;
+	if (!record(value)) malformed("balance detail");
+	const suggested = typeof value.suggestedDeposit === "string" && /^-?\d+(\.\d+)?$/.test(value.suggestedDeposit) ? Number(value.suggestedDeposit) : providerNumber(value.suggestedDeposit);
+	return {
+		subTotal: providerNumber(value.subTotal),
+		additionalItems: providerNumber(value.additionalItems),
+		taxesFees: providerNumber(value.taxesFees),
+		grandTotal: providerNumber(value.grandTotal),
+		paid: providerNumber(value.paid),
+		suggestedDeposit: suggested
+	};
+}
+function reservationDetail(raw, property) {
+	if (typeof raw.status !== "string" || !STATUSES.has(raw.status)) malformed("reservation status");
+	if (raw.assigned !== void 0 && !Array.isArray(raw.assigned) || raw.unassigned !== void 0 && !Array.isArray(raw.unassigned) || raw.guestList !== void 0 && raw.guestList !== null && !record(raw.guestList)) malformed("reservation detail");
+	const assignedRooms = (raw.assigned ?? []).map((room) => reservationRoom(room, true));
+	const unassignedRooms = (raw.unassigned ?? []).map((room) => reservationRoom(room, false));
+	const mainGuest = (record(raw.guestList) ? Object.values(raw.guestList) : []).find((guest) => record(guest) && guest.isMainGuest === true);
+	const guestId = record(mainGuest) && typeof mainGuest.guestID === "string" && PROVIDER_ID.test(mainGuest.guestID) ? mainGuest.guestID : null;
+	const rooms = [...assignedRooms, ...unassignedRooms];
+	const sum = (field) => rooms.every((room) => typeof room[field] === "number") ? rooms.reduce((total, room) => total + room[field], 0) : null;
+	return {
+		propertyId: property,
+		reservationId: raw.reservationID,
+		status: raw.status,
+		arrivalDate: providerDate(raw.startDate),
+		departureDate: providerDate(raw.endDate),
+		guestId,
+		guestName: providerText(raw.guestName),
+		adults: sum("adults"),
+		children: sum("children"),
+		assignedRooms,
+		unassignedRooms,
+		total: providerNumber(raw.total),
+		balance: providerNumber(raw.balance),
+		balanceDetailed: balanceDetailed(raw.balanceDetailed),
+		source: providerText(raw.source),
+		sourceId: providerText(raw.sourceID)
+	};
+}
+function guestDetail(result, property, guestId) {
+	const raw = result.data;
+	if (!record(raw) || raw.firstName !== void 0 && typeof raw.firstName !== "string" || raw.lastName !== void 0 && typeof raw.lastName !== "string") malformed("guest");
+	const text = (value) => providerText(value) || null;
+	return {
+		propertyId: property,
+		guestId,
+		firstName: text(raw.firstName),
+		lastName: text(raw.lastName),
+		email: text(raw.email),
+		phone: text(raw.phone),
+		cellPhone: text(raw.cellPhone),
+		country: text(raw.country),
+		nationality: text(raw.guestNationality),
+		isAnonymized: raw.isAnonymized === true,
+		mergedIntoGuestId: raw.isMerged === true && typeof raw.newGuestID === "string" && PROVIDER_ID.test(raw.newGuestID) ? raw.newGuestID : null
+	};
+}
+function guestNotes(result, property, guestId) {
+	if (!Array.isArray(result.data)) malformed("guest notes");
+	return {
+		propertyId: property,
+		guestId,
+		notes: result.data.map((raw) => {
+			if (!record(raw) || typeof raw.guestNoteID !== "string" || !PROVIDER_ID.test(raw.guestNoteID) || typeof raw.guestNote !== "string") malformed("guest notes");
+			return {
+				noteId: raw.guestNoteID,
+				note: providerText(raw.guestNote, 4e3),
+				author: providerText(raw.userName),
+				createdAt: providerText(raw.dateCreated),
+				modifiedAt: providerText(raw.dateModified)
+			};
+		})
+	};
+}
+function housekeepingQuery(args, property) {
+	const query = new URLSearchParams({ propertyID: property });
+	if (args.roomId !== void 0) query.set("roomIDs", providerId(args.roomId, "roomId"));
+	if (args.roomCondition !== void 0) {
+		if (typeof args.roomCondition !== "string" || !ROOM_CONDITIONS.has(args.roomCondition)) throw new Error("cloudbeds: invalid roomCondition");
+		query.set("roomCondition", args.roomCondition);
+	}
+	query.set("pageNumber", String(page(args.pageNumber, "pageNumber", 1, 1e5)));
+	query.set("pageSize", String(page(args.pageSize, "pageSize", 100, 500)));
+	return query;
+}
+function housekeepingRoom(raw) {
+	if (!record(raw) || typeof raw.roomID !== "string" || !PROVIDER_ID.test(raw.roomID) || typeof raw.roomCondition !== "string" || !REPORTED_ROOM_CONDITIONS.has(raw.roomCondition) || typeof raw.roomOccupied !== "boolean" || raw.doNotDisturb !== void 0 && typeof raw.doNotDisturb !== "boolean" || raw.roomBlocked !== void 0 && typeof raw.roomBlocked !== "boolean") malformed("housekeeping status");
+	return {
+		roomId: raw.roomID,
+		roomName: providerText(raw.roomName),
+		roomTypeId: typeof raw.roomTypeID === "string" && PROVIDER_ID.test(raw.roomTypeID) ? raw.roomTypeID : null,
+		roomTypeName: providerText(raw.roomTypeName),
+		roomCondition: raw.roomCondition,
+		roomOccupied: raw.roomOccupied,
+		doNotDisturb: raw.doNotDisturb === true,
+		roomBlocked: raw.roomBlocked === true,
+		frontdeskStatus: typeof raw.frontdeskStatus === "string" && FRONTDESK_STATUSES.has(raw.frontdeskStatus) ? raw.frontdeskStatus : null,
+		housekeeperId: typeof raw.housekeeperID === "string" && PROVIDER_ID.test(raw.housekeeperID) ? raw.housekeeperID : null,
+		housekeeper: providerText(raw.housekeeper) || null,
+		conditionDate: typeof raw.date === "string" && DATE.test(raw.date) ? raw.date : null
+	};
+}
+function housekeeping(result, property, query) {
+	const pageSize = Number(query.get("pageSize"));
+	const rooms = pagination(result, pageSize, "housekeeping").map(housekeepingRoom);
+	const roomId = query.get("roomIDs");
+	if (roomId && rooms.some((room) => room.roomId !== roomId)) malformed("housekeeping status for another room");
+	const pageNumber = Number(query.get("pageNumber"));
+	return {
+		propertyId: property,
+		rooms,
+		pageNumber,
+		pageSize,
+		total: result.total,
+		hasMore: pageNumber * pageSize < result.total
+	};
+}
+function ratePlanQuery(args, property) {
+	const startDate = date(args.startDate, "startDate");
+	const endDate = date(args.endDate, "endDate");
+	const days = nights(startDate, endDate);
+	if (days < 1 || days > 31) throw new Error("cloudbeds: stay must be between 1 and 31 nights");
+	const query = new URLSearchParams({
+		propertyIDs: property,
+		startDate,
+		endDate,
+		detailedRates: "false"
+	});
+	if (args.roomTypeId !== void 0) query.set("roomTypeID", providerId(args.roomTypeId, "roomTypeId"));
+	return query;
+}
+function ratePlans(result, property, query) {
+	if (!Array.isArray(result.data) || result.data.length > 2e3) malformed("rate plans");
+	const roomTypeId = query.get("roomTypeID");
+	const rates = result.data.map((raw) => {
+		if (!record(raw) || raw.propertyID !== void 0 && raw.propertyID !== null && String(raw.propertyID) !== property) throw new ProviderProtocolError("Cloudbeds returned a rate outside the connected property", "invalid_response");
+		if (typeof raw.rateID !== "string" || !PROVIDER_ID.test(raw.rateID) || raw.roomRate !== void 0 && providerNumber(raw.roomRate) === null || raw.totalRate !== void 0 && providerNumber(raw.totalRate) === null || raw.roomsAvailable !== void 0 && (!Number.isSafeInteger(raw.roomsAvailable) || raw.roomsAvailable < 0)) malformed("rate plans");
+		const rowRoomType = typeof raw.roomTypeID === "string" && PROVIDER_ID.test(raw.roomTypeID) ? raw.roomTypeID : roomTypeId;
+		if (roomTypeId && rowRoomType !== roomTypeId) malformed("rate plans for another room type");
+		return {
+			rateId: raw.rateID,
+			ratePlanId: typeof raw.ratePlanID === "string" && PROVIDER_ID.test(raw.ratePlanID) ? raw.ratePlanID : null,
+			ratePlanName: providerText(raw.ratePlanNamePublic) || null,
+			roomTypeId: rowRoomType,
+			roomTypeName: providerText(typeof raw.roomTypeName === "number" ? String(raw.roomTypeName) : raw.roomTypeName),
+			roomRate: providerNumber(raw.roomRate),
+			totalRate: providerNumber(raw.totalRate),
+			roomsAvailable: typeof raw.roomsAvailable === "number" ? raw.roomsAvailable : null,
+			isDerived: raw.isDerived === true
+		};
+	});
+	return {
+		propertyId: property,
+		startDate: query.get("startDate"),
+		endDate: query.get("endDate"),
+		rates
+	};
+}
+function formForItem(inv, property) {
+	const args = inv.args;
+	const reservationId = boundedString(args.reservationId, "reservationId");
+	const appItemId = boundedString(args.appItemId, "appItemId");
+	const itemName = boundedString(args.itemName, "itemName");
+	const itemCategoryName = boundedString(args.itemCategoryName, "itemCategoryName");
+	const itemPrice = money(args.itemPrice, "itemPrice");
+	const itemQuantity = page(args.itemQuantity, "itemQuantity", 1, 1e3);
+	if (!OPERATION_ID.test(inv.idempotencyKey)) throw new Error("cloudbeds: stable bounded idempotencyKey is required");
+	if (!Array.isArray(args.taxes) || args.taxes.length > 10) throw new Error("cloudbeds: explicit taxes array is required");
+	const form = new URLSearchParams({
+		propertyID: property,
+		reservationID: reservationId,
+		referenceID: inv.idempotencyKey,
+		"items[0][appItemID]": appItemId,
+		"items[0][itemName]": itemName,
+		"items[0][itemCategoryName]": itemCategoryName,
+		"items[0][itemPrice]": itemPrice.toFixed(2),
+		"items[0][itemQuantity]": String(itemQuantity),
+		itemPaid: "false"
+	});
+	args.taxes.forEach((tax, index) => {
+		if (!record(tax)) throw new Error("cloudbeds: invalid tax");
+		form.set(`items[0][itemTaxes][${index}][taxName]`, boundedString(tax.taxName, "taxName"));
+		form.set(`items[0][itemTaxes][${index}][taxValue]`, money(tax.taxValue, "taxValue", true).toFixed(2));
+	});
+	return form;
+}
+async function postFolioItem(inv, property) {
+	const body = formForItem(inv, property);
+	await readReservation(inv.source, property, body.get("reservationID"));
+	const result = await call(inv.source, "postCustomItem", form(body));
+	if (!record(result.data)) throw new ProviderProtocolError("Cloudbeds returned a malformed folio item receipt", "invalid_response");
+	const soldProductId = typeof result.data.soldProductID === "string" && result.data.soldProductID ? result.data.soldProductID : null;
+	const notice = providerText(result.data.notice);
+	const duplicate = soldProductId === null && notice !== null && /referenceid/i.test(notice) && /nothing was created/i.test(notice);
+	if (!soldProductId && !duplicate) throw new ProviderProtocolError("Cloudbeds returned an indeterminate folio item receipt", "capability_outcome_indeterminate");
+	return {
+		status: "committed",
+		data: {
+			referenceId: inv.idempotencyKey,
+			soldProductId,
+			transactionId: typeof result.data.transactionID === "string" ? result.data.transactionID : null,
+			duplicate,
+			notice
+		},
+		committedAt: Date.now(),
+		idempotentReplay: duplicate
+	};
+}
+async function updateHousekeeping(inv, property) {
+	const roomId = providerId(inv.args.roomId, "roomId");
+	const roomCondition = inv.args.roomCondition;
+	if (typeof roomCondition !== "string" || !ROOM_CONDITIONS.has(roomCondition)) throw new Error("cloudbeds: invalid roomCondition");
+	if (inv.args.doNotDisturb !== void 0 && typeof inv.args.doNotDisturb !== "boolean") throw new Error("cloudbeds: invalid doNotDisturb");
+	const query = new URLSearchParams({
+		propertyID: property,
+		roomIDs: roomId,
+		pageNumber: "1",
+		pageSize: "1"
+	});
+	const before = housekeeping(await call(inv.source, `getHousekeepingStatus?${query}`, { method: "GET" }), property, query).rooms[0];
+	if (!before) throw new Error("cloudbeds: room is not part of the connected property");
+	const body = new URLSearchParams({
+		propertyID: property,
+		roomID: roomId,
+		roomCondition
+	});
+	if (typeof inv.args.doNotDisturb === "boolean") body.set("doNotDisturb", String(inv.args.doNotDisturb));
+	const result = await call(inv.source, "postHousekeepingStatus", form(body));
+	if (!record(result.data) || result.data.roomID !== roomId || result.data.roomCondition !== roomCondition || typeof inv.args.doNotDisturb === "boolean" && result.data.doNotDisturb !== void 0 && result.data.doNotDisturb !== null && result.data.doNotDisturb !== inv.args.doNotDisturb) throw new ProviderProtocolError("Cloudbeds returned an indeterminate housekeeping receipt", "capability_outcome_indeterminate");
+	return {
+		status: "committed",
+		committedAt: Date.now(),
+		idempotentReplay: false,
+		data: {
+			propertyId: property,
+			roomId,
+			roomCondition,
+			previousCondition: before.roomCondition,
+			doNotDisturb: typeof result.data.doNotDisturb === "boolean" ? result.data.doNotDisturb : before.doNotDisturb
+		}
+	};
+}
+async function listWebhooks(source, property) {
+	const result = await call(source, `getWebhooks?${new URLSearchParams({ propertyID: property })}`, { method: "GET" });
+	if (!Array.isArray(result.data) || result.data.length > 1e3) malformed("webhook subscriptions");
+	return result.data.map((raw) => {
+		if (!record(raw) || typeof raw.id !== "string" || !/^[A-Za-z0-9_-]{1,128}$/.test(raw.id) || !record(raw.event) || raw.key !== void 0 && raw.key !== null && !record(raw.key)) malformed("webhook subscriptions");
+		if (record(raw.key) && raw.key.type === "property" && String(raw.key.id) !== property) throw new ProviderProtocolError("Cloudbeds returned a webhook subscription outside the connected property", "invalid_response");
+		const data = record(raw.subscriptionData) ? raw.subscriptionData : {};
+		return {
+			subscriptionId: raw.id,
+			object: providerText(raw.event.entity),
+			action: providerText(raw.event.action),
+			endpointUrl: providerText(data.endpoint ?? data.url, 2048),
+			authHeaderName: record(raw.authHeader) ? providerText(raw.authHeader.name) : null
+		};
+	});
+}
+function webhookEndpoint(value) {
+	const text = boundedString(value, "endpointUrl", 2048);
+	let url;
+	try {
+		url = new URL(text);
+	} catch {
+		throw new Error("cloudbeds: invalid endpointUrl");
+	}
+	if (url.protocol !== "https:" || url.username || url.password || url.hash) throw new Error("cloudbeds: endpointUrl must be an https URL without credentials or fragment");
+	return text;
+}
+function redact(error, secret) {
+	if (secret && error instanceof Error && error.message.includes(secret)) error.message = error.message.split(secret).join("[redacted]");
+	return error;
+}
+async function subscribeWebhook(inv, property) {
+	const args = inv.args;
+	const event = CLOUDBEDS_WEBHOOK_EVENTS.find((item) => item.object === args.object && item.action === args.action);
+	if (!event) throw new Error("cloudbeds: unsupported webhook event");
+	const endpointUrl = webhookEndpoint(args.endpointUrl);
+	if (args.authHeaderName === void 0 !== (args.authHeaderValue === void 0)) throw new Error("cloudbeds: authHeaderName and authHeaderValue must be sent together");
+	let authHeaderName = null;
+	let authHeaderValue = null;
+	if (args.authHeaderName !== void 0) {
+		if (typeof args.authHeaderName !== "string" || !HEADER_NAME.test(args.authHeaderName)) throw new Error("cloudbeds: invalid authHeaderName");
+		if (typeof args.authHeaderValue !== "string" || !/^[!-~](?:[ -~]{0,1022}[!-~])?$/.test(args.authHeaderValue)) throw new Error("cloudbeds: invalid authHeaderValue");
+		authHeaderName = args.authHeaderName;
+		authHeaderValue = args.authHeaderValue;
+	}
+	try {
+		const existing = (await listWebhooks(inv.source, property)).find((row) => row.object === event.object && row.action === event.action && row.endpointUrl === endpointUrl);
+		const receipt = {
+			propertyId: property,
+			object: event.object,
+			action: event.action,
+			endpointUrl,
+			authHeaderName
+		};
+		if (existing && authHeaderValue === null) return {
+			status: "committed",
+			committedAt: Date.now(),
+			idempotentReplay: true,
+			data: {
+				...receipt,
+				subscriptionId: existing.subscriptionId,
+				authHeaderName: existing.authHeaderName,
+				existing: true
+			}
+		};
+		const body = new URLSearchParams({
+			propertyID: property,
+			object: event.object,
+			action: event.action,
+			endpointUrl
+		});
+		if (authHeaderName && authHeaderValue) {
+			body.set("authHeaderName", authHeaderName);
+			body.set("authHeaderValue", authHeaderValue);
+		}
+		const result = await call(inv.source, "postWebhook", form(body));
+		if (!record(result.data) || typeof result.data.subscriptionID !== "string" || !/^[A-Za-z0-9_-]{1,128}$/.test(result.data.subscriptionID)) throw new ProviderProtocolError("Cloudbeds returned an indeterminate webhook subscription receipt", "capability_outcome_indeterminate");
+		return {
+			status: "committed",
+			committedAt: Date.now(),
+			idempotentReplay: false,
+			data: {
+				...receipt,
+				subscriptionId: result.data.subscriptionID,
+				existing: existing !== void 0
+			}
+		};
+	} catch (error) {
+		throw redact(error, authHeaderValue);
+	}
+}
+async function deleteWebhook(inv, property) {
+	const subscriptionId = inv.args.subscriptionId;
+	if (typeof subscriptionId !== "string" || !/^[A-Za-z0-9_-]{1,128}$/.test(subscriptionId)) throw new Error("cloudbeds: invalid subscriptionId");
+	if (!(await listWebhooks(inv.source, property)).find((row) => row.subscriptionId === subscriptionId)) return {
+		status: "committed",
+		committedAt: Date.now(),
+		idempotentReplay: true,
+		data: {
+			propertyId: property,
+			subscriptionId,
+			deleted: false,
+			alreadyAbsent: true
+		}
+	};
+	await call(inv.source, `deleteWebhook?${new URLSearchParams({
+		propertyIDs: property,
+		subscriptionID: subscriptionId
+	})}`, { method: "DELETE" });
+	return {
+		status: "committed",
+		committedAt: Date.now(),
+		idempotentReplay: false,
+		data: {
+			propertyId: property,
+			subscriptionId,
+			deleted: true,
+			alreadyAbsent: false
+		}
+	};
+}
+const PAGE = {
+	pageNumber: {
+		type: "integer",
+		minimum: 1,
+		maximum: 1e5
+	},
+	pageSize: {
+		type: "integer",
+		minimum: 1,
+		maximum: 100
+	}
+};
+const ID = {
+	type: "string",
+	pattern: PROVIDER_ID.source
+};
+const STAY = {
+	startDate: {
+		type: "string",
+		format: "date"
+	},
+	endDate: {
+		type: "string",
+		format: "date"
+	}
+};
+const cloudbedsConnector = {
+	manifest: {
+		kind: "cloudbeds",
+		displayName: "Cloudbeds",
+		description: "Read reservations, guests, housekeeping, rates and room availability for one connected property, update room condition, manage reservation webhooks, and post an approved custom item to a guest folio.",
+		auth: {
+			kind: "api-key",
+			hint: "Property-scoped Cloudbeds API key with read:reservation, read:room, read:guest, read:housekeeping, write:housekeeping, read:rate and write:item scopes. Set the connection propertyId."
+		},
+		category: "other",
+		defaultConsistencyModel: "authoritative",
+		capabilities: [
+			{
+				name: "reservations.list",
+				class: "read",
+				requiredScopes: ["read:reservation"],
+				description: "List one page of arrivals, departures, or in-house guests (status checked_in with no dates) for the connected property, with room type, room ID and room name lists. Guest requirements are never requested.",
+				parameters: {
+					type: "object",
+					properties: {
+						checkInFrom: {
+							type: "string",
+							format: "date"
+						},
+						checkInTo: {
+							type: "string",
+							format: "date"
+						},
+						checkOutFrom: {
+							type: "string",
+							format: "date"
+						},
+						checkOutTo: {
+							type: "string",
+							format: "date"
+						},
+						status: {
+							type: "string",
+							enum: [...STATUSES]
+						},
+						...PAGE
+					}
+				}
+			},
+			{
+				name: "reservations.get",
+				class: "read",
+				requiredScopes: ["read:reservation"],
+				description: "Read one reservation of the connected property: status, stay dates, main guest, assigned and unassigned rooms, guest counts, source, total, balance and balanceDetailed (paid and owed amounts; Cloudbeds v1.3 has no payments read).",
+				parameters: {
+					type: "object",
+					properties: { reservationId: {
+						type: "string",
+						minLength: 1,
+						maxLength: 256
+					} },
+					required: ["reservationId"]
+				}
+			},
+			{
+				name: "guests.get",
+				class: "read",
+				requiredScopes: ["read:guest"],
+				description: "Read one guest's name, email, phone, country and nationality at the connected property. Identity documents, address and birth date are never returned.",
+				parameters: {
+					type: "object",
+					properties: { guestId: ID },
+					required: ["guestId"]
+				}
+			},
+			{
+				name: "guests.notes",
+				class: "read",
+				requiredScopes: ["read:guest"],
+				description: "Read staff notes on one guest at the connected property.",
+				parameters: {
+					type: "object",
+					properties: { guestId: ID },
+					required: ["guestId"]
+				}
+			},
+			{
+				name: "housekeeping.status",
+				class: "read",
+				requiredScopes: ["read:housekeeping"],
+				description: "Read today's housekeeping status for the connected property: room condition, occupancy, do-not-disturb, front-desk status and housekeeper.",
+				parameters: {
+					type: "object",
+					properties: {
+						roomId: ID,
+						roomCondition: {
+							type: "string",
+							enum: [...ROOM_CONDITIONS]
+						},
+						pageNumber: PAGE.pageNumber,
+						pageSize: {
+							type: "integer",
+							minimum: 1,
+							maximum: 500
+						}
+					}
+				}
+			},
+			{
+				name: "housekeeping.update",
+				class: "mutation",
+				cas: "optimistic-read-verify",
+				externalEffect: false,
+				requiredScopes: ["read:housekeeping", "write:housekeeping"],
+				description: "Verify the room belongs to the connected property, then set today's room condition to clean or dirty and optionally do-not-disturb. Setting an explicit condition is idempotent.",
+				parameters: {
+					type: "object",
+					properties: {
+						roomId: ID,
+						roomCondition: {
+							type: "string",
+							enum: [...ROOM_CONDITIONS]
+						},
+						doNotDisturb: { type: "boolean" }
+					},
+					required: ["roomId", "roomCondition"]
+				}
+			},
+			{
+				name: "rate-plans.list",
+				class: "read",
+				requiredScopes: ["read:rate"],
+				description: "Read publicly sellable rate plans and stay rates for 1 to 31 nights at the connected property, optionally for one room type. This does not hold or price a booking.",
+				parameters: {
+					type: "object",
+					properties: {
+						...STAY,
+						roomTypeId: ID
+					},
+					required: ["startDate", "endDate"]
+				}
+			},
+			{
+				name: "room-types.available",
+				class: "read",
+				requiredScopes: ["read:room"],
+				description: "Read provider-reported room-type availability for a stay at the connected property. This does not hold or confirm a booking.",
+				parameters: {
+					type: "object",
+					properties: {
+						...STAY,
+						rooms: {
+							type: "integer",
+							minimum: 1,
+							maximum: 10
+						},
+						adults: {
+							type: "integer",
+							minimum: 1,
+							maximum: 20
+						},
+						children: {
+							type: "integer",
+							minimum: 0,
+							maximum: 20
+						},
+						...PAGE
+					},
+					required: ["startDate", "endDate"]
+				}
+			},
+			{
+				name: "folio-items.post",
+				class: "mutation",
+				cas: "native-idempotency",
+				externalEffect: true,
+				requiredScopes: ["read:reservation", "write:item"],
+				description: "Verify reservation ownership, then post one unpaid custom item to the connected property guest folio. The Hub operation key becomes Cloudbeds referenceID.",
+				parameters: {
+					type: "object",
+					properties: {
+						reservationId: {
+							type: "string",
+							minLength: 1,
+							maxLength: 256
+						},
+						appItemId: {
+							type: "string",
+							minLength: 1,
+							maxLength: 256
+						},
+						itemName: {
+							type: "string",
+							minLength: 1,
+							maxLength: 256
+						},
+						itemCategoryName: {
+							type: "string",
+							minLength: 1,
+							maxLength: 256
+						},
+						itemPrice: {
+							type: "number",
+							minimum: .01,
+							maximum: 1e6,
+							multipleOf: .01
+						},
+						itemQuantity: {
+							type: "integer",
+							minimum: 1,
+							maximum: 1e3
+						},
+						taxes: {
+							type: "array",
+							description: "Explicit tax amounts in the property currency. Use [] only when no tax applies.",
+							maxItems: 10,
+							items: {
+								type: "object",
+								properties: {
+									taxName: {
+										type: "string",
+										minLength: 1,
+										maxLength: 256
+									},
+									taxValue: {
+										type: "number",
+										minimum: 0,
+										maximum: 1e6,
+										multipleOf: .01
+									}
+								},
+								required: ["taxName", "taxValue"]
+							}
+						}
+					},
+					required: [
+						"reservationId",
+						"appItemId",
+						"itemName",
+						"itemCategoryName",
+						"itemPrice",
+						"taxes"
+					]
+				}
+			},
+			{
+				name: "webhooks.subscribe",
+				class: "mutation",
+				cas: "optimistic-read-verify",
+				externalEffect: true,
+				requiredScopes: ["read:reservation"],
+				description: "Subscribe an https endpoint to one reservation event for the connected property, reusing a matching subscription. An optional auth header is sent by Cloudbeds on every delivery and is never returned.",
+				parameters: {
+					type: "object",
+					properties: {
+						object: {
+							type: "string",
+							enum: ["reservation"]
+						},
+						action: {
+							type: "string",
+							enum: CLOUDBEDS_WEBHOOK_EVENTS.map((event) => event.action)
+						},
+						endpointUrl: {
+							type: "string",
+							format: "uri",
+							maxLength: 2048
+						},
+						authHeaderName: {
+							type: "string",
+							pattern: HEADER_NAME.source
+						},
+						authHeaderValue: {
+							type: "string",
+							minLength: 1,
+							maxLength: 1024
+						}
+					},
+					required: [
+						"object",
+						"action",
+						"endpointUrl"
+					]
+				}
+			},
+			{
+				name: "webhooks.list",
+				class: "read",
+				requiredScopes: ["read:reservation"],
+				description: "List webhook subscriptions visible to the connected property. Auth header values are never returned.",
+				parameters: {
+					type: "object",
+					properties: {}
+				}
+			},
+			{
+				name: "webhooks.delete",
+				class: "mutation",
+				cas: "optimistic-read-verify",
+				externalEffect: true,
+				requiredScopes: ["read:reservation"],
+				description: "Delete one webhook subscription after confirming it is visible to the connected property. A missing subscription is reported as already absent.",
+				parameters: {
+					type: "object",
+					properties: { subscriptionId: {
+						type: "string",
+						pattern: "^[A-Za-z0-9_-]{1,128}$"
+					} },
+					required: ["subscriptionId"]
+				}
+			}
+		]
+	},
+	async executeRead(inv) {
+		const property = propertyId(inv.source);
+		const read = async (path) => call(inv.source, path, { method: "GET" });
+		let data;
+		switch (inv.capabilityName) {
+			case "reservations.list": {
+				const query = reservationQuery(inv.args, property);
+				data = reservations(await read(`getReservations?${query}`), property, query);
+				break;
+			}
+			case "reservations.get": {
+				const reservationId = boundedString(inv.args.reservationId, "reservationId");
+				data = reservationDetail(await readReservation(inv.source, property, reservationId), property);
+				break;
+			}
+			case "guests.get": {
+				const guestId = providerId(inv.args.guestId, "guestId");
+				data = guestDetail(await read(`getGuest?${new URLSearchParams({
+					propertyID: property,
+					guestID: guestId
+				})}`), property, guestId);
+				break;
+			}
+			case "guests.notes": {
+				const guestId = providerId(inv.args.guestId, "guestId");
+				data = guestNotes(await read(`getGuestNotes?${new URLSearchParams({
+					propertyID: property,
+					guestID: guestId
+				})}`), property, guestId);
+				break;
+			}
+			case "housekeeping.status": {
+				const query = housekeepingQuery(inv.args, property);
+				data = housekeeping(await read(`getHousekeepingStatus?${query}`), property, query);
+				break;
+			}
+			case "rate-plans.list": {
+				const query = ratePlanQuery(inv.args, property);
+				data = ratePlans(await read(`getRatePlans?${query}`), property, query);
+				break;
+			}
+			case "room-types.available": {
+				const query = roomAvailabilityQuery(inv.args, property);
+				data = roomAvailability(await read(`getAvailableRoomTypes?${query}`), property, query);
+				break;
+			}
+			case "webhooks.list":
+				data = {
+					propertyId: property,
+					subscriptions: await listWebhooks(inv.source, property)
+				};
+				break;
+			default: throw new Error(`cloudbeds: unknown read ${inv.capabilityName}`);
+		}
+		return {
+			data,
+			fetchedAt: Date.now()
+		};
+	},
+	async executeMutation(inv) {
+		const property = propertyId(inv.source);
+		switch (inv.capabilityName) {
+			case "folio-items.post": return postFolioItem(inv, property);
+			case "housekeeping.update": return updateHousekeeping(inv, property);
+			case "webhooks.subscribe": return subscribeWebhook(inv, property);
+			case "webhooks.delete": return deleteWebhook(inv, property);
+			default: throw new Error(`cloudbeds: unknown mutation ${inv.capabilityName}`);
+		}
+	},
+	async test(source) {
+		try {
+			const property = propertyId(source);
+			const result = await call(source, `getReservations?${new URLSearchParams({
+				propertyID: property,
+				status: "checked_in",
+				pageNumber: "1",
+				pageSize: "1"
+			})}`, { method: "GET" });
+			if (!Array.isArray(result.data)) throw new ProviderProtocolError("Cloudbeds returned malformed reservations", "invalid_response");
+			return { ok: true };
+		} catch (error) {
+			return {
+				ok: false,
+				reason: error instanceof Error ? error.message : "Cloudbeds connection failed"
+			};
+		}
+	}
+};
+function roomAvailabilityQuery(args, property) {
+	const startDate = date(args.startDate, "startDate");
+	const endDate = date(args.endDate, "endDate");
+	const days = nights(startDate, endDate);
+	if (days < 1 || days > 31) throw new Error("cloudbeds: stay must be between 1 and 31 nights");
+	const children = args.children ?? 0;
+	if (!Number.isSafeInteger(children) || children < 0 || children > 20) throw new Error("cloudbeds: invalid children");
+	return new URLSearchParams({
+		propertyIDs: property,
+		startDate,
+		endDate,
+		rooms: String(page(args.rooms, "rooms", 1, 10)),
+		adults: String(page(args.adults, "adults", 1, 20)),
+		children: String(children),
+		pageNumber: String(page(args.pageNumber, "pageNumber", 1, 1e5)),
+		pageSize: String(page(args.pageSize, "pageSize", 100, 100)),
+		detailedRates: "false",
+		includeSharedRooms: "false"
+	});
+}
+function roomAvailability(result, property, query) {
+	if (!Array.isArray(result.data) || !Number.isSafeInteger(result.count) || !Number.isSafeInteger(result.total) || !Number.isSafeInteger(result.roomCount) || result.count < 0 || result.count > 1 || result.total < result.count || result.count !== result.data.length || result.roomCount < 0 || result.count > Number(query.get("pageSize"))) throw new ProviderProtocolError("Cloudbeds returned malformed room availability pagination", "invalid_response");
+	const roomTypes = result.data.flatMap((raw) => {
+		if (!record(raw) || raw.propertyID !== property || !Array.isArray(raw.propertyRooms)) throw new ProviderProtocolError("Cloudbeds returned availability outside the connected property", "invalid_response");
+		return raw.propertyRooms.map((room) => {
+			if (!record(room) || typeof room.roomTypeID !== "string" || !room.roomTypeID || !Number.isSafeInteger(room.roomsAvailable) || room.roomsAvailable < 0 || room.roomRate !== void 0 && (typeof room.roomRate !== "number" || !Number.isFinite(room.roomRate) || room.roomRate < 0)) throw new ProviderProtocolError("Cloudbeds returned malformed room-type availability", "invalid_response");
+			return {
+				roomTypeId: room.roomTypeID,
+				roomTypeName: providerText(room.roomTypeName),
+				roomsAvailable: room.roomsAvailable,
+				roomRate: typeof room.roomRate === "number" ? room.roomRate : null
+			};
+		});
+	});
+	if (roomTypes.length !== result.roomCount) throw new ProviderProtocolError("Cloudbeds returned mismatched room-type count", "invalid_response");
+	return {
+		propertyId: property,
+		startDate: query.get("startDate"),
+		endDate: query.get("endDate"),
+		rooms: Number(query.get("rooms")),
+		adults: Number(query.get("adults")),
+		children: Number(query.get("children")),
+		roomTypes,
+		pageNumber: Number(query.get("pageNumber")),
+		pageSize: Number(query.get("pageSize")),
+		mayHaveMore: Number(query.get("pageNumber")) * Number(query.get("pageSize")) < result.total
+	};
+}
+//#endregion
+export { parseStripeSignatureHeader as a, verifySlackSignature as c, firstHeader as i, verifyStripeSignature as l, cloudbedsConnector as n, verifyEmailSignature as o, DEFAULT_SIGNATURE_TOLERANCE_SECONDS as r, verifyHmacSignature as s, CLOUDBEDS_WEBHOOK_EVENTS as t, verifyTwilioSignature as u };
+
+//# sourceMappingURL=cloudbeds-BL5EF3xl.js.map