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

package/npm-dist/index.cjs

@@ -0,0 +1,1993 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _prismatic_io_spectral = require("@prismatic-io/spectral");
+let json_bigint = require("json-bigint");
+json_bigint = __toESM(json_bigint);
+let _prismatic_io_spectral_http = require("@prismatic-io/spectral/http");
+//#region src/constants.ts
+const GENERAL_DELETE_MESSAGE = { data: { message: "Action performed successfully." } };
+const MODEL_FOR_OPTIONAL_BOOLEAN_INPUTS = ["True", "False"].map((value) => ({
+	value: value.toLowerCase(),
+	label: value
+}));
+const WEBINAR_TYPE_MODEL = [
+	{
+		value: "single_session",
+		label: "Single Session"
+	},
+	{
+		value: "series",
+		label: "Series"
+	},
+	{
+		value: "sequence",
+		label: "Sequence"
+	}
+];
+const AVAILABLE_LOCALES_FOR_WEBINAR_MODEL = [
+	{
+		value: "en_US",
+		label: "English (United States)"
+	},
+	{
+		value: "fr_FR",
+		label: "French (France)"
+	},
+	{
+		value: "de_DE",
+		label: "German (Germany)"
+	},
+	{
+		value: "es_ES",
+		label: "Spanish (Spain)"
+	},
+	{
+		value: "it_IT",
+		label: "Italian (Italy)"
+	},
+	{
+		value: "zh_CN",
+		label: "Chinese (China)"
+	}
+];
+const AVAILABLE_EXPERIENCES_MODEL = [
+	{
+		value: "CLASSIC",
+		label: "Classic"
+	},
+	{
+		value: "SIMULIVE",
+		label: "Simulive"
+	},
+	{
+		value: "BROADCAST",
+		label: "Broadcast"
+	}
+];
+const EVENT_NAMES_MODEL = [
+	{
+		value: "registrant.added",
+		label: "Registrant Added"
+	},
+	{
+		value: "registrant.joined",
+		label: "Registrant Joined"
+	},
+	{
+		value: "webinar.created",
+		label: "Webinar Created"
+	},
+	{
+		value: "webinar.changed",
+		label: "Webinar Changed"
+	}
+];
+const USER_SUBSCRIPTION_STATUS_MODEL = [{
+	value: "ACTIVE",
+	label: "Active"
+}, {
+	value: "INACTIVE",
+	label: "Inactive"
+}];
+//#endregion
+//#region src/util/index.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 toOptionalBoolean = (value) => {
+	const str = _prismatic_io_spectral.util.types.toString(value);
+	return str === "true" ? true : str === "false" ? false : void 0;
+};
+const toOptionalEmailSetting = (value) => {
+	const bool = toOptionalBoolean(value);
+	if (bool === void 0) return;
+	return { enabled: bool };
+};
+const toOptionalObject = (value) => {
+	if (!value) return;
+	return _prismatic_io_spectral.util.types.toObject(value);
+};
+const lookBackDateClean = (value) => {
+	const str = _prismatic_io_spectral.util.types.toString(value).trim();
+	if (!str) return "";
+	if (!/^\d{4}-\d{2}-\d{2}$/.test(str)) throw new Error("Look-back Date must be in YYYY-MM-DD format.");
+	const [year, month, day] = str.split("-").map((part) => _prismatic_io_spectral.util.types.toNumber(part));
+	const parsed = new Date(year, month - 1, day);
+	if (parsed.getFullYear() !== year || parsed.getMonth() !== month - 1 || parsed.getDate() !== day) throw new Error(`Look-back Date "${str}" is not a valid calendar date.`);
+	if (parsed > /* @__PURE__ */ new Date()) throw new Error("Look-back Date cannot be a future date.");
+	return str;
+};
+const getT = async (client, url, key, params) => {
+	const { data: { _embedded } } = await client.get(url, { params });
+	if (!_embedded) return [];
+	return _embedded[key];
+};
+const filterAndMapByCallbackUrl = (callbackUrls, collection, keyToMapBy) => {
+	return collection.filter((o) => callbackUrls.includes(o.callbackUrl)).map((o) => o[keyToMapBy]);
+};
+const deleteByKeys = async (client, url, collectionKeys) => {
+	await client.delete(url, { data: collectionKeys });
+};
+const bigIntTransformerConfig = { transformResponse: [(data) => {
+	if (typeof data === "string") return json_bigint.default.parse(data);
+	return data;
+}] };
+const parseRegistrantKey = (registrantKey) => {
+	return registrantKey.reduce((acc, element) => {
+		return `${acc}${element}`;
+	}, "");
+};
+const deleteInstancedWebhooks = async (client, callbackUrls, params) => {
+	const NO_WEBHOOKS = 0;
+	const webhooks = await getT(client, "/webhooks", "webhooks", params);
+	if (webhooks.length === NO_WEBHOOKS) return;
+	const instanceWebhookKeys = filterAndMapByCallbackUrl(callbackUrls, webhooks, "webhookKey");
+	await deleteByKeys(client, "/webhooks", instanceWebhookKeys);
+	const userSubscriptions = await getT(client, "/userSubscriptions", "userSubscriptions", params);
+	const instanceUserSubscriptions = filterAndMapByCallbackUrl(callbackUrls, userSubscriptions, "userSubscriptionKey");
+	await deleteByKeys(client, "/userSubscriptions", instanceUserSubscriptions);
+};
+const getFromTime = () => {
+	const from = /* @__PURE__ */ new Date(/* @__PURE__ */ new Date());
+	from.setMonth(from.getMonth() - 3);
+	from.setHours(0, 0, 0, 0);
+	return `${from.toISOString().slice(0, 19)}Z`;
+};
+const getEndTime = () => {
+	const end = /* @__PURE__ */ new Date(/* @__PURE__ */ new Date());
+	end.setHours(23, 59, 59, 999);
+	return `${end.toISOString().slice(0, 19)}Z`;
+};
+const fetchAllResults = async (client, url, key, params) => {
+	const results = [];
+	const size = 5;
+	let pageNumber = 0;
+	let totalPages = 0;
+	do {
+		const { data: { page, _embedded } } = await client.get(url, { params: {
+			...params,
+			size,
+			page: pageNumber
+		} });
+		if (_embedded?.[key]) results.push(..._embedded[key]);
+		totalPages = page.totalPages;
+		pageNumber += 1;
+	} while (pageNumber <= totalPages);
+	return results;
+};
+const fetchAllRegistrants = async (client, organizerKey, webinarKey) => {
+	const url = `/organizers/${organizerKey}/webinars/${webinarKey}/registrants`;
+	const all = [];
+	for (let page = 0; page < 50; page += 1) {
+		const { data } = await client.get(url, {
+			params: {
+				page,
+				limit: 200
+			},
+			transformResponse: bigIntTransformerConfig.transformResponse
+		});
+		if (!Array.isArray(data) || data.length === 0) break;
+		all.push(...data.map((registrant) => ({
+			...registrant,
+			registrantKey: parseRegistrantKey(registrant.registrantKey.c)
+		})));
+		if (data.length < 200) break;
+	}
+	return all;
+};
+const filterRegistrantsRegisteredAfter = (registrants, lastPolledAt) => {
+	const lastPolledAtMs = new Date(lastPolledAt).getTime();
+	return registrants.filter((registrant) => {
+		const registeredMs = registrant.registrationDate ? new Date(registrant.registrationDate).getTime() : NaN;
+		return !Number.isNaN(registeredMs) && registeredMs > lastPolledAtMs;
+	});
+};
+const lookBackDateToCursor = (lookBackDate) => (/* @__PURE__ */ new Date(Date.parse(`${lookBackDate}T00:00:00.000Z`) - 1)).toISOString();
+const resolvePollingRecordChanges = (data) => {
+	return [...((data ?? { created: [] }).created ?? []).map((record) => ({
+		changeType: "created",
+		record
+	}))];
+};
+//#endregion
+//#region src/inputs/common.ts
+const connection = (0, _prismatic_io_spectral.input)({
+	label: "Connection",
+	type: "connection",
+	required: true
+});
+const pageNumber = (0, _prismatic_io_spectral.input)({
+	label: "Page Number",
+	comments: "The zero-based index of the page to return. The first page is 0.",
+	type: "string",
+	required: false,
+	example: "0",
+	placeholder: "Enter a page number",
+	clean: toOptionalNumber
+});
+const pageSize = (0, _prismatic_io_spectral.input)({
+	label: "Page Size",
+	comments: "The maximum number of results to return per page. The maximum value is 200.",
+	type: "string",
+	required: false,
+	example: "200",
+	placeholder: "Enter a page size",
+	clean: (value) => {
+		const size = toOptionalNumber(value);
+		if (!size) return size;
+		return size > 200 ? 200 : size;
+	}
+});
+const fromTime = (0, _prismatic_io_spectral.input)({
+	label: "From Time",
+	comments: "The start of the date/time range to query, in ISO 8601 UTC format. Format: YYYY-MM-DDThh:mm:ssZ.",
+	type: "string",
+	required: true,
+	example: "2020-03-13T10:00:00Z",
+	placeholder: "Enter a start date/time",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const toTime = (0, _prismatic_io_spectral.input)({
+	label: "To Time",
+	comments: "The end of the date/time range to query, in ISO 8601 UTC format. Format: YYYY-MM-DDThh:mm:ssZ.",
+	type: "string",
+	required: true,
+	example: "2020-03-13T10:00:00Z",
+	placeholder: "Enter an end date/time",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const accountKey = (0, _prismatic_io_spectral.input)({
+	label: "Account Key",
+	comments: "The unique identifier for the account.",
+	type: "string",
+	required: true,
+	example: "1234567890",
+	placeholder: "Enter an account key",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const webinarKey = (0, _prismatic_io_spectral.input)({
+	label: "Webinar Key",
+	comments: "The unique identifier for the webinar.",
+	type: "string",
+	required: true,
+	example: "1234567890",
+	placeholder: "Enter a webinar key",
+	clean: _prismatic_io_spectral.util.types.toString,
+	dataSource: "selectWebinar"
+});
+const timezone = (0, _prismatic_io_spectral.input)({
+	label: "Timezone",
+	comments: "The time zone where the webinar is taking place (must be a valid time zone ID). If this parameter is not passed, the timezone of the organizer's profile will be used.",
+	type: "string",
+	required: false,
+	example: "America/Chicago",
+	placeholder: "Enter a time zone ID",
+	clean: toOptionalString
+});
+const webinarType = (0, _prismatic_io_spectral.input)({
+	label: "Webinar Type",
+	comments: "The scheduling format for the webinar. Select 'Single Session' for a one-time event, 'Series' for multiple related sessions, or 'Sequence' for an ordered set of sessions.",
+	type: "string",
+	required: true,
+	model: WEBINAR_TYPE_MODEL,
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const locale = (0, _prismatic_io_spectral.input)({
+	label: "Locale",
+	comments: "The language and region used for the webinar's display text.",
+	type: "string",
+	required: false,
+	model: AVAILABLE_LOCALES_FOR_WEBINAR_MODEL,
+	example: "en_US",
+	placeholder: "Enter a locale",
+	clean: toOptionalString
+});
+const registrantKey = (0, _prismatic_io_spectral.input)({
+	label: "Registrant Key",
+	comments: "The unique identifier for the registrant.",
+	type: "string",
+	required: true,
+	example: "1234567890",
+	placeholder: "Enter a registrant key",
+	clean: _prismatic_io_spectral.util.types.toString,
+	dataSource: "selectRegistrant"
+});
+const sessionKey = (0, _prismatic_io_spectral.input)({
+	label: "Session Key",
+	comments: "The unique identifier for the webinar session.",
+	type: "string",
+	required: true,
+	example: "1234567890",
+	placeholder: "Enter a session key",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const userSubscriptionKey = (0, _prismatic_io_spectral.input)({
+	label: "User Subscription Key",
+	comments: "The unique identifier for the user subscription.",
+	type: "string",
+	required: true,
+	example: "1234567890",
+	placeholder: "Enter a user subscription key",
+	clean: _prismatic_io_spectral.util.types.toString,
+	dataSource: "selectWebhook"
+});
+const fetchAll = (0, _prismatic_io_spectral.input)({
+	label: "Fetch All",
+	comments: "When true, automatically fetches all pages of results using pagination. When false, only the first page is fetched.",
+	type: "boolean",
+	required: false,
+	clean: _prismatic_io_spectral.util.types.toBool
+});
+//#endregion
+//#region src/inputs/attendees.ts
+const getAttendeeInputs = {
+	connection,
+	webinarKey,
+	sessionKey,
+	registrantKey
+};
+const listAllAttendeesInputs = {
+	connection,
+	webinarKey,
+	fetchAll
+};
+const listSessionAttendeesInputs = {
+	connection,
+	webinarKey,
+	sessionKey
+};
+//#endregion
+//#region src/inputs/registrants.ts
+const firstName = (0, _prismatic_io_spectral.input)({
+	label: "First Name",
+	comments: "The first name of the registrant.",
+	type: "string",
+	required: true,
+	example: "John",
+	placeholder: "Enter a first name",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const lastName = (0, _prismatic_io_spectral.input)({
+	label: "Last Name",
+	comments: "The last name of the registrant.",
+	type: "string",
+	required: true,
+	example: "Doe",
+	placeholder: "Enter a last name",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const email = (0, _prismatic_io_spectral.input)({
+	label: "Email",
+	comments: "The email address of the registrant.",
+	type: "string",
+	required: true,
+	example: "johndoe@testemail.com",
+	placeholder: "Enter an email address",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const source = (0, _prismatic_io_spectral.input)({
+	label: "Source",
+	comments: "The source that led to the registration. This can be any string like 'Newsletter 123' or 'Marketing campaign ABC'.",
+	type: "string",
+	required: false,
+	example: "website",
+	placeholder: "Enter a registration source",
+	clean: toOptionalString
+});
+const address = (0, _prismatic_io_spectral.input)({
+	label: "Address",
+	comments: "The street address of the registrant.",
+	type: "string",
+	required: false,
+	example: "123 Main St",
+	placeholder: "Enter a street address",
+	clean: toOptionalString
+});
+const city = (0, _prismatic_io_spectral.input)({
+	label: "City",
+	comments: "The city of the registrant.",
+	type: "string",
+	required: false,
+	example: "Sioux Falls",
+	placeholder: "Enter a city",
+	clean: toOptionalString
+});
+const state = (0, _prismatic_io_spectral.input)({
+	label: "State",
+	comments: "The state or province of the registrant.",
+	type: "string",
+	required: false,
+	example: "South Dakota",
+	placeholder: "Enter a state",
+	clean: toOptionalString
+});
+const zipCode = (0, _prismatic_io_spectral.input)({
+	label: "Zip Code",
+	comments: "The postal code of the registrant.",
+	type: "string",
+	required: false,
+	example: "57104",
+	placeholder: "Enter a zip code",
+	clean: toOptionalString
+});
+const country = (0, _prismatic_io_spectral.input)({
+	label: "Country",
+	comments: "The country of the registrant.",
+	type: "string",
+	required: false,
+	example: "United States",
+	placeholder: "Enter a country",
+	clean: toOptionalString
+});
+const phone = (0, _prismatic_io_spectral.input)({
+	label: "Phone",
+	comments: "The phone number of the registrant.",
+	type: "string",
+	required: false,
+	example: "605-555-5555",
+	placeholder: "Enter a phone number",
+	clean: toOptionalString
+});
+const organization = (0, _prismatic_io_spectral.input)({
+	label: "Organization",
+	comments: "The organization the registrant belongs to.",
+	type: "string",
+	required: false,
+	example: "Acme Corp",
+	placeholder: "Enter an organization",
+	clean: toOptionalString
+});
+const jobTitle = (0, _prismatic_io_spectral.input)({
+	label: "Job Title",
+	comments: "The job title of the registrant.",
+	type: "string",
+	required: false,
+	example: "Software Engineer",
+	placeholder: "Enter a job title",
+	clean: toOptionalString
+});
+const questionAndComments = (0, _prismatic_io_spectral.input)({
+	label: "Questions and Comments",
+	comments: "Any questions or comments submitted by the registrant.",
+	type: "string",
+	required: false,
+	example: "I have a question about the webinar.",
+	placeholder: "Enter any questions or comments",
+	clean: toOptionalString
+});
+const industry = (0, _prismatic_io_spectral.input)({
+	label: "Industry",
+	comments: "The industry the registrant works in.",
+	type: "string",
+	required: false,
+	example: "IT",
+	placeholder: "Enter an industry",
+	clean: toOptionalString
+});
+const numberOfEmployees = (0, _prismatic_io_spectral.input)({
+	label: "Number of Employees",
+	comments: "The number of employees in the registrant's organization.",
+	type: "string",
+	required: false,
+	example: "100",
+	placeholder: "Enter a number of employees",
+	clean: toOptionalNumber
+});
+const purchasingTimeFrame = (0, _prismatic_io_spectral.input)({
+	label: "Purchasing Time Frame",
+	comments: "The time frame within which the product will be purchased.",
+	type: "string",
+	required: false,
+	example: "1-3 months",
+	placeholder: "Enter a purchasing time frame",
+	clean: toOptionalString
+});
+const purchasingRole = (0, _prismatic_io_spectral.input)({
+	label: "Purchasing Role",
+	comments: "The role of the registrant in the purchasing process.",
+	type: "string",
+	required: false,
+	example: "Decision Maker",
+	placeholder: "Enter a purchasing role",
+	clean: toOptionalString
+});
+const responses = (0, _prismatic_io_spectral.input)({
+	label: "Responses",
+	comments: "The answers to the webinar's custom registration questions. Provide a JSON array of question/response objects.",
+	type: "code",
+	language: "json",
+	required: false,
+	example: JSON.stringify([{
+		questionKey: "qkey",
+		responseText: "responseText",
+		answerKey: "akey"
+	}], null, 2),
+	clean: toOptionalObject
+});
+const createRegistrantInputs = {
+	connection,
+	firstName,
+	lastName,
+	webinarKey,
+	email,
+	phone,
+	source,
+	mailingAddress: (0, _prismatic_io_spectral.structuredObjectInput)({
+		label: "Address",
+		required: false,
+		comments: "Street address, city, state, zip code, and country.",
+		inputs: {
+			address,
+			city,
+			state,
+			zipCode,
+			country
+		}
+	}),
+	additionalFields: (0, _prismatic_io_spectral.structuredObjectInput)({
+		label: "Additional Fields",
+		required: false,
+		comments: "Additional optional fields: includes Organization, Job Title, Industry, Number of Employees, Purchasing Time Frame, Purchasing Role, Questions and Comments, and Responses.",
+		inputs: {
+			organization,
+			jobTitle,
+			industry,
+			numberOfEmployees,
+			purchasingTimeFrame,
+			purchasingRole,
+			questionAndComments,
+			responses
+		}
+	})
+};
+const getRegistrantInputs = {
+	connection,
+	webinarKey,
+	registrantKey
+};
+const deleteRegistrantInputs = getRegistrantInputs;
+const listRegistrantsInputs = {
+	connection,
+	webinarKey,
+	pagination: (0, _prismatic_io_spectral.structuredObjectInput)({
+		label: "Pagination",
+		required: false,
+		comments: "Page number and page size for paginated results.",
+		inputs: {
+			page: pageNumber,
+			limit: pageSize
+		}
+	})
+};
+//#endregion
+//#region src/inputs/triggers.ts
+const lookBackDate = (0, _prismatic_io_spectral.input)({
+	label: "Look-back Date",
+	placeholder: "Enter look-back date (YYYY-MM-DD)",
+	type: "string",
+	required: false,
+	comments: "The date the initial sync starts from, in YYYY-MM-DD format. Cannot be a future date. Leave empty to start from the first recurrence with no backfill. When set, the initial sync seeds each registrant who registered on or after this date once.",
+	example: "2026-01-01",
+	clean: lookBackDateClean
+});
+//#endregion
+//#region src/inputs/userSubscriptions.ts
+const webhookUrl = (0, _prismatic_io_spectral.input)({
+	label: "Webhook URL",
+	comments: "The HTTPS URL that receives posted webhook events. The endpoint must return 200 OK for GET requests.",
+	type: "string",
+	required: true,
+	example: "https://example.com/webhook",
+	placeholder: "Enter a webhook URL",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const eventName = (0, _prismatic_io_spectral.input)({
+	label: "Event Name",
+	comments: "The event to subscribe to.",
+	type: "string",
+	required: true,
+	model: EVENT_NAMES_MODEL,
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const eventVersion = (0, _prismatic_io_spectral.input)({
+	label: "Event Version",
+	comments: "The schema version of the event payload to receive.",
+	type: "string",
+	required: true,
+	default: "1.0.0",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const userSubscriptionKeys = (0, _prismatic_io_spectral.input)({
+	label: "User Subscription Keys",
+	comments: "The user subscription keys to act upon. Provide a JSON array of key strings.",
+	type: "code",
+	language: "json",
+	required: true,
+	example: JSON.stringify(["subscription_id1", "subscription_id2"], null, 2),
+	clean: (value) => {
+		return _prismatic_io_spectral.util.types.toObject(value).map((us) => {
+			return _prismatic_io_spectral.util.types.toString(us);
+		});
+	}
+});
+const deleteWebhook = (0, _prismatic_io_spectral.input)({
+	label: "Delete Webhooks",
+	comments: "When true, the affiliated webhook is deleted along with the user subscription. Note that deleting the webhook will also delete any other user subscriptions tied to the corresponding webhook key.",
+	type: "boolean",
+	required: true,
+	clean: _prismatic_io_spectral.util.types.toBool
+});
+const webhookKey = (0, _prismatic_io_spectral.input)({
+	label: "Webhook Key",
+	comments: "The unique identifier for the webhook to update.",
+	type: "string",
+	required: true,
+	example: "webhookKey1",
+	placeholder: "Enter a webhook key",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const updateUserSubscriptionKey = (0, _prismatic_io_spectral.input)({
+	label: "User Subscription Key",
+	comments: "The unique identifier for the user subscription to update.",
+	type: "string",
+	required: true,
+	example: "userSubscriptionKey1",
+	placeholder: "Enter a user subscription key",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const userSubscriptionState = (0, _prismatic_io_spectral.input)({
+	label: "User Subscription State",
+	comments: "The status to apply to the user subscription.",
+	type: "string",
+	required: true,
+	example: "ACTIVE",
+	placeholder: "Enter a subscription state",
+	clean: _prismatic_io_spectral.util.types.toString,
+	model: USER_SUBSCRIPTION_STATUS_MODEL
+});
+const getUserSubscriptionInputs = {
+	connection,
+	userSubscriptionKey
+};
+const listUserSubscriptionsInputs = { connection };
+const createUserSubscriptionInputs = {
+	connection,
+	webhookUrl,
+	eventName,
+	eventVersion
+};
+const updateUserSubscriptionInputs = {
+	connection,
+	webhookKey,
+	userSubscriptionKey: updateUserSubscriptionKey,
+	userSubscriptionState,
+	callbackUrl: {
+		...webhookUrl,
+		required: false,
+		clean: toOptionalString
+	}
+};
+const deleteUserSubscriptionInputs = {
+	connection,
+	userSubscriptionKeys,
+	deleteWebhook
+};
+//#endregion
+//#region src/inputs/webhooks.ts
+const deleteInstancedWebhooksInputs = { connection };
+//#endregion
+//#region src/inputs/webinars.ts
+const subject = (0, _prismatic_io_spectral.input)({
+	label: "Subject",
+	comments: "The title displayed for the webinar.",
+	type: "string",
+	required: true,
+	example: "How to Create a Webinar",
+	placeholder: "Enter a subject",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const description = (0, _prismatic_io_spectral.input)({
+	label: "Description",
+	comments: "A summary of what the webinar covers.",
+	type: "string",
+	required: false,
+	example: "Learn how to create a webinar from scratch",
+	placeholder: "Enter a description",
+	clean: toOptionalString
+});
+const times = (0, _prismatic_io_spectral.input)({
+	label: "Time Range for Webinar",
+	comments: "Time Range Array for the webinar. Please note that the examples provided describe the expected payload given all webinar types. Only one array should be used based on the webinar type.",
+	type: "code",
+	language: "json",
+	required: true,
+	example: JSON.stringify([
+		{ single_session_webinar_type_example: [{
+			startTime: "2020-03-13T10:00:00Z",
+			endTime: "2020-03-13T11:00:00Z"
+		}] },
+		{ series_webinar_type_example: [{
+			startTime: "2020-03-13T10:00:00Z",
+			endTime: "2020-03-13T11:00:00Z"
+		}, {
+			startTime: "2020-03-20T10:00:00Z",
+			endTime: "2020-03-20T11:00:00Z"
+		}] },
+		{ sequence_webinar_type_example: [{
+			startTime: "2020-03-13T10:00:00Z",
+			endTime: "2020-03-13T11:00:00Z"
+		}] }
+	]),
+	clean: _prismatic_io_spectral.util.types.toObject
+});
+const isPasswordProtected = (0, _prismatic_io_spectral.input)({
+	label: "Is Password Protected",
+	comments: "Indicates if the webinar is password protected.",
+	type: "string",
+	required: false,
+	model: MODEL_FOR_OPTIONAL_BOOLEAN_INPUTS,
+	default: "false",
+	clean: toOptionalBoolean
+});
+const recordingAssetKey = (0, _prismatic_io_spectral.input)({
+	label: "Recording Asset Key",
+	comments: "The recording asset with which the simulive webinar should be created from. In case the recordingasset was created as an online recording the simulive webinar settings, poll and surveys would be copied from the webinar whose session was recorded.",
+	type: "string",
+	required: false,
+	example: "your-recording-asset-key",
+	placeholder: "Enter a recording asset key",
+	clean: toOptionalString
+});
+const isOndemand = (0, _prismatic_io_spectral.input)({
+	label: "Is On Demand",
+	comments: "A boolean flag indicating if the webinar should be On-Demand.",
+	type: "string",
+	required: false,
+	model: MODEL_FOR_OPTIONAL_BOOLEAN_INPUTS,
+	default: "false",
+	clean: toOptionalBoolean
+});
+const isBreakout = (0, _prismatic_io_spectral.input)({
+	label: "Is Breakout",
+	comments: "A boolean flag indicating if the webinar should be breakout.",
+	type: "string",
+	required: false,
+	model: MODEL_FOR_OPTIONAL_BOOLEAN_INPUTS,
+	default: "false",
+	clean: toOptionalBoolean
+});
+const experienceType = (0, _prismatic_io_spectral.input)({
+	label: "Experience Type",
+	comments: "The experience type of the webinar.",
+	type: "string",
+	required: false,
+	default: AVAILABLE_EXPERIENCES_MODEL[0].value,
+	model: AVAILABLE_EXPERIENCES_MODEL,
+	clean: toOptionalString
+});
+const confirmationEmail = (0, _prismatic_io_spectral.input)({
+	label: "Should Send Confirmation Email",
+	comments: "Whether or not to send a confirmation email to the registrants.",
+	type: "string",
+	required: false,
+	model: MODEL_FOR_OPTIONAL_BOOLEAN_INPUTS,
+	clean: toOptionalEmailSetting
+});
+const reminderEmail = (0, _prismatic_io_spectral.input)({
+	label: "Should Send Reminder Email",
+	comments: "Whether or not to send a reminder email to the registrants.",
+	type: "string",
+	required: false,
+	model: MODEL_FOR_OPTIONAL_BOOLEAN_INPUTS,
+	clean: toOptionalEmailSetting
+});
+const absenteeFollowUpEmail = (0, _prismatic_io_spectral.input)({
+	label: "Should Send Absentee Follow Up Email",
+	comments: "Whether or not to send an absentee follow up email to the registrants.",
+	type: "string",
+	required: false,
+	model: MODEL_FOR_OPTIONAL_BOOLEAN_INPUTS,
+	clean: toOptionalEmailSetting
+});
+const attendeeFollowUpEmail = (0, _prismatic_io_spectral.input)({
+	label: "Should Send Attendee Follow Up Email",
+	comments: "Whether or not to send an attendee follow up email to the registrants.",
+	type: "string",
+	required: false,
+	model: MODEL_FOR_OPTIONAL_BOOLEAN_INPUTS,
+	clean: toOptionalEmailSetting
+});
+const sendCancellationEmail = (0, _prismatic_io_spectral.input)({
+	label: "Send Cancellation Email",
+	comments: "Indicates whether cancellation notice emails should be sent. Default behavior is false.",
+	type: "string",
+	model: MODEL_FOR_OPTIONAL_BOOLEAN_INPUTS,
+	required: false,
+	clean: toOptionalBoolean
+});
+const deleteAll = (0, _prismatic_io_spectral.input)({
+	label: "Delete All",
+	comments: "Specifies whether all scheduled sessions should be deleted if the webinar is part of a series. Default behavior is true.",
+	type: "string",
+	model: MODEL_FOR_OPTIONAL_BOOLEAN_INPUTS,
+	required: false,
+	default: "false",
+	clean: toOptionalBoolean
+});
+const notifyParticipants = (0, _prismatic_io_spectral.input)({
+	label: "Notify Participants",
+	comments: "Notify participants of the webinar.",
+	type: "boolean",
+	required: true,
+	clean: _prismatic_io_spectral.util.types.toBool
+});
+const emailSettings = (0, _prismatic_io_spectral.structuredObjectInput)({
+	label: "Email Settings",
+	required: false,
+	comments: "Configure which automated emails are sent to registrants for the webinar.",
+	inputs: {
+		confirmationEmail,
+		reminderEmail,
+		absenteeFollowUpEmail,
+		attendeeFollowUpEmail
+	}
+});
+const createWebinarInputs = {
+	connection,
+	subject,
+	webinarType,
+	times,
+	description,
+	experienceType,
+	timeZone: timezone,
+	emailSettings,
+	additionalFields: (0, _prismatic_io_spectral.structuredObjectInput)({
+		label: "Additional Fields",
+		required: false,
+		comments: "Additional optional fields: includes Recording Asset Key, Is On Demand, Is Breakout, Is Password Protected, and Locale.",
+		inputs: {
+			recordingAssetKey,
+			isOndemand,
+			isBreakout,
+			isPasswordProtected,
+			locale
+		}
+	})
+};
+const pagination = (0, _prismatic_io_spectral.structuredObjectInput)({
+	label: "Pagination",
+	required: false,
+	comments: "Page number and page size for paginated results.",
+	inputs: {
+		page: pageNumber,
+		size: pageSize
+	}
+});
+const getWebinarInputs = {
+	connection,
+	fromTime,
+	toTime,
+	accountKey: {
+		...accountKey,
+		clean: toOptionalString,
+		required: false,
+		comments: "The key of the account. If using this input instead of the organizer key, the action will retrieve the webinars by Account Key"
+	},
+	fetchAll,
+	pagination
+};
+const updateWebinarInputs = {
+	connection,
+	webinarKey,
+	notifyParticipants,
+	subject: {
+		...subject,
+		required: false,
+		clean: toOptionalString
+	},
+	description,
+	times: {
+		...times,
+		required: false,
+		comments: "The time range of the webinar.",
+		clean: toOptionalObject,
+		example: JSON.stringify([{
+			startTime: "2020-03-13T10:00:00Z",
+			endTime: "2020-03-13T11:00:00Z"
+		}])
+	},
+	timeZone: timezone,
+	locale,
+	emailSettings
+};
+const deleteWebinarInputs = {
+	connection,
+	webinarKey,
+	sendCancellationEmail,
+	deleteAll
+};
+//#endregion
+//#region src/connections/index.ts
+const gotoWebinarOAuth2Connection = (0, _prismatic_io_spectral.oauth2Connection)({
+	key: "gotoWebinarOAuth2Connection",
+	oauth2Type: _prismatic_io_spectral.OAuth2Type.AuthorizationCode,
+	display: {
+		label: "OAuth 2.0",
+		description: "Authenticate requests to GoTo Webinar using OAuth 2.0."
+	},
+	inputs: {
+		authorizeUrl: {
+			label: "Authorize URL",
+			comments: "The OAuth2 Authorize URL for GoTo Webinar.",
+			type: "string",
+			required: true,
+			shown: false,
+			default: "https://authentication.logmeininc.com/oauth/authorize"
+		},
+		tokenUrl: {
+			label: "Token URL",
+			comments: "The OAuth2 Token URL for GoTo Webinar",
+			type: "string",
+			required: true,
+			shown: false,
+			default: "https://authentication.logmeininc.com/oauth/token"
+		},
+		scopes: {
+			label: "Scopes",
+			comments: "Space separated list of OAuth2 scopes for GoTo Webinar.",
+			type: "string",
+			required: true,
+			shown: true,
+			default: "identity:scim.me collab:"
+		},
+		clientId: {
+			label: "Client ID",
+			comments: "The OAuth2 Client ID for GoTo Webinar.",
+			type: "string",
+			required: true,
+			shown: true
+		},
+		clientSecret: {
+			label: "Client Secret",
+			comments: "The OAuth2 Client Secret for GoTo Webinar.",
+			type: "password",
+			required: true,
+			shown: true
+		},
+		organizerKey: {
+			label: "Organizer Key",
+			comments: "The GoTo Webinar Organizer Key.",
+			type: "string",
+			required: true,
+			shown: true
+		}
+	}
+});
+var connections_default = [gotoWebinarOAuth2Connection];
+//#endregion
+//#region src/client.ts
+const getAuthorizationHeaders = ({ connection }) => {
+	switch (connection.key) {
+		case gotoWebinarOAuth2Connection.key: {
+			const token = _prismatic_io_spectral.util.types.toString(connection.token?.access_token);
+			if (!token) throw new _prismatic_io_spectral.ConnectionError(connection, "No access token found in connection");
+			return { Authorization: `Bearer ${token}` };
+		}
+		default: throw new _prismatic_io_spectral.ConnectionError(connection, "Unsupported Connection");
+	}
+};
+const getClientProps = (connection) => {
+	const token = _prismatic_io_spectral.util.types.toString(connection.token?.access_token);
+	const organizerKey = _prismatic_io_spectral.util.types.toString(connection.fields?.organizerKey);
+	if (!token) throw new _prismatic_io_spectral.ConnectionError(connection, "No access token found in connection");
+	if (!organizerKey) throw new _prismatic_io_spectral.ConnectionError(connection, "No organizer key found in connection");
+	return {
+		token,
+		organizerKey,
+		baseUrl: "https://api.getgo.com/G2W/rest/v2"
+	};
+};
+const createGotoWebinarClient = (connection, debug = false) => {
+	const headers = getAuthorizationHeaders({ connection });
+	const { baseUrl } = getClientProps(connection);
+	return {
+		organizerKey: _prismatic_io_spectral.util.types.toString(connection.fields?.organizerKey),
+		client: (0, _prismatic_io_spectral_http.createClient)({
+			baseUrl,
+			headers: {
+				...headers,
+				"Content-Type": "application/json",
+				Accept: "application/vnd.citrix.g2wapi-v1.1+json"
+			},
+			debug
+		})
+	};
+};
+//#endregion
+//#region src/examplePayloads/actions.ts
+const GET_WEBINARS_EXAMPLE_PAYLOAD = { data: {
+	_embedded: { webinars: [{
+		webinarKey: "8978964909939938573",
+		webinarID: "204586973",
+		organizerKey: "8456783923409587345",
+		accountKey: "9384756102938475610",
+		subject: "Q3 Product Launch Webinar",
+		description: "Join us for a live walkthrough of our latest product features.",
+		times: [{
+			startTime: "2024-09-10T15:00:00Z",
+			endTime: "2024-09-10T16:00:00Z"
+		}],
+		timeZone: "America/New_York",
+		locale: "en_US",
+		approvalType: "AUTOMATIC",
+		registrationUrl: "https://attendee.gotowebinar.com/register/8978964909939938573",
+		impromptu: false,
+		isPasswordProtected: false,
+		recurrenceType: "single_session",
+		experienceType: "CLASSIC"
+	}] },
+	page: {
+		size: 20,
+		totalElements: 1,
+		totalPages: 1,
+		number: 0
+	}
+} };
+const DELETE_WEBINAR_EXAMPLE_PAYLOAD = GENERAL_DELETE_MESSAGE;
+const CREATE_WEBINAR_EXAMPLE_PAYLOAD = { data: {
+	webinarKey: "8978964909939938573",
+	recurrenceKey: "5647382910564738291"
+} };
+const UPDATE_WEBINAR_EXAMPLE_PAYLOAD = GENERAL_DELETE_MESSAGE;
+const CREATE_REGISTRANT_EXAMPLE_PAYLOAD = { data: {
+	registrantKey: "1234567890",
+	joinUrl: "https://global.gotowebinar.com/join/8978964909939938573/1234567890"
+} };
+const GET_REGISTRANTS_EXAMPLE_PAYLOAD = { data: {
+	lastName: "Doe",
+	email: "jane.doe@example.com",
+	firstName: "Jane",
+	registrantKey: "1234567890",
+	registrationDate: "2024-08-24T14:15:22Z",
+	source: "Marketing Email",
+	status: "APPROVED",
+	joinUrl: "https://global.gotowebinar.com/join/8978964909939938573/1234567890",
+	timeZone: "America/New_York",
+	phone: "+1-555-123-4567",
+	state: "New York",
+	city: "New York",
+	organization: "Acme Corporation",
+	zipCode: "10001",
+	numberOfEmployees: "201-500",
+	industry: "Technology",
+	jobTitle: "Engineering Manager",
+	purchasingRole: "Decision Maker",
+	implementationTimeFrame: "1-3 months",
+	purchasingTimeFrame: "Within 6 months",
+	questionsAndComments: "Looking forward to the demo.",
+	employeeCount: "250",
+	country: "United States",
+	address: "123 Main Street",
+	type: "LATE",
+	unsubscribed: false,
+	responses: [{
+		answer: "Yes",
+		question: "Are you currently evaluating webinar platforms?"
+	}]
+} };
+const LIST_REGISTRANTS_EXAMPLE_PAYLOAD = { data: [{
+	lastName: "Doe",
+	email: "jane.doe@example.com",
+	firstName: "Jane",
+	registrantKey: "1234567890",
+	registrationDate: "2024-08-24T14:15:22Z",
+	status: "APPROVED",
+	joinUrl: "https://global.gotowebinar.com/join/8978964909939938573/1234567890",
+	timeZone: "America/New_York"
+}, {
+	lastName: "Smith",
+	email: "john.smith@example.com",
+	firstName: "John",
+	registrantKey: "9876543210",
+	registrationDate: "2024-08-25T09:42:10Z",
+	status: "WAITING",
+	joinUrl: "https://global.gotowebinar.com/join/8978964909939938573/9876543210",
+	timeZone: "America/Los_Angeles"
+}] };
+const LIST_ALL_ATTEENDEES_FOR_ALL_WEBINAR_SESSIONS_EXAMPLE_PAYLOAD = { data: {
+	property1: {
+		sessionInfo: {
+			webinarName: "Q3 Product Launch Webinar",
+			webinarId: "204586973",
+			sessionKey: "111111111111111111",
+			timeZone: "America/New_York",
+			experienceType: "CLASSIC",
+			recurrencePeriod: "SINGLE_SESSION",
+			startTime: "2024-09-10T15:00:00Z",
+			endTime: "2024-09-10T16:00:00Z",
+			registrationEmailOpenedCount: "120",
+			registrationLinkClickedCount: "95"
+		},
+		attendance: {
+			registrantCount: 150,
+			percentageAttendance: 72.5,
+			averageInterestRating: 4.2,
+			averageAttentiveness: .87,
+			averageAttendanceTimeSeconds: 2640
+		},
+		pollsAndSurveys: {
+			pollCount: 3,
+			surveyCount: 1,
+			questionsAsked: 12,
+			percentagePollsCompleted: 68.4,
+			percentageSurveysCompleted: 41.2
+		}
+	},
+	property2: {
+		sessionInfo: {
+			webinarName: "Q3 Product Launch Webinar",
+			webinarId: "204586973",
+			sessionKey: "222222222222222222",
+			timeZone: "America/New_York",
+			experienceType: "CLASSIC",
+			recurrencePeriod: "SINGLE_SESSION",
+			startTime: "2024-09-17T15:00:00Z",
+			endTime: "2024-09-17T16:00:00Z",
+			registrationEmailOpenedCount: "98",
+			registrationLinkClickedCount: "80"
+		},
+		attendance: {
+			registrantCount: 130,
+			percentageAttendance: 65,
+			averageInterestRating: 3.9,
+			averageAttentiveness: .81,
+			averageAttendanceTimeSeconds: 2400
+		},
+		pollsAndSurveys: {
+			pollCount: 2,
+			surveyCount: 1,
+			questionsAsked: 8,
+			percentagePollsCompleted: 55,
+			percentageSurveysCompleted: 38.5
+		}
+	}
+} };
+const LIST_SESSION_ATTENDEES_EXAMPLE_PAYLOAD = { data: [{
+	registrantKey: 1234567890,
+	firstName: "Jane",
+	lastName: "Doe",
+	email: "jane.doe@example.com",
+	attendanceTimeInSeconds: 3540,
+	sessionKey: 204586973,
+	attendance: [{
+		joinTime: "2024-09-10T15:01:30Z",
+		leaveTime: "2024-09-10T16:00:30Z"
+	}]
+}] };
+const GET_ATTENDEE_EXAMPLE_PAYLOAD = { data: {
+	lastName: "Doe",
+	email: "jane.doe@example.com",
+	firstName: "Jane",
+	registrantKey: 1234567890,
+	registrationDate: "2024-08-24T14:15:22Z",
+	status: "APPROVED",
+	joinUrl: "https://global.gotowebinar.com/join/8978964909939938573/1234567890",
+	timeZone: "America/New_York"
+} };
+const GET_USER_SUBSCRIPTION_EXAMPLE_PAYLOAD = { data: {
+	callbackUrl: "https://hooks.example.com/gotowebinar/registrant-added",
+	eventName: "registrant.added",
+	eventVersion: "1.0.0",
+	product: "g2w",
+	webhookKey: "7766554433221100",
+	userSubscriptionKey: "5544332211009988",
+	userSubscriptionState: "ACTIVE",
+	activationState: "ACTIVATED",
+	createTime: "2024-08-20T10:30:00Z"
+} };
+const CREATE_USER_SUBSCRIPTION_EXAMPLE_PAYLOAD = { data: { _embedded: { userSubscriptions: [{
+	callbackUrl: "https://hooks.example.com/gotowebinar/registrant-added",
+	eventName: "registrant.added",
+	eventVersion: "1.0.0",
+	product: "g2w",
+	webhookKey: "7766554433221100",
+	userSubscriptionKey: "5544332211009988",
+	userSubscriptionState: "ACTIVE",
+	activationState: "ACTIVATED",
+	createTime: "2024-08-20T10:30:00Z"
+}] } } };
+const LIST_USER_SUBSCRIPTIONS_EXAMPLE_PAYLOAD = { data: { _embedded: { userSubscriptions: [{
+	callbackUrl: "https://hooks.example.com/gotowebinar/registrant-added",
+	eventName: "registrant.added",
+	eventVersion: "1.0.0",
+	product: "g2w",
+	webhookKey: "7766554433221100",
+	userSubscriptionKey: "5544332211009988",
+	userSubscriptionState: "ACTIVE",
+	activationState: "ACTIVATED",
+	createTime: "2024-08-20T10:30:00Z"
+}] } } };
+const pollChangesTriggerExamplePayload = { payload: {
+	headers: {},
+	queryParameters: {},
+	rawBody: { data: null },
+	body: { data: { created: [LIST_REGISTRANTS_EXAMPLE_PAYLOAD.data[0]] } },
+	pathFragment: "",
+	webhookUrls: {},
+	webhookApiKeys: {},
+	invokeUrl: "",
+	executionId: "RXhhbXBsZUV4ZWN1dGlvblJlc3VsdElk",
+	customer: {
+		id: "testCustomerId",
+		name: "Test Customer",
+		externalId: "testExternalId"
+	},
+	instance: {
+		id: "testInstanceId",
+		name: "Test Instance"
+	},
+	user: {
+		id: "testUserId",
+		email: "user@example.com",
+		name: "Test User",
+		externalId: "testUserExternalId"
+	},
+	integration: {
+		id: "testIntegrationId",
+		name: "Test Integration",
+		versionSequenceId: "1",
+		externalVersion: ""
+	},
+	flow: {
+		id: "testFlowId",
+		name: "Test Flow",
+		stableId: "testFlowStableId"
+	},
+	startedAt: "2024-01-15T00:00:00.000Z",
+	globalDebug: false
+} };
+const userSubscriptionTriggerExamplePayload = { payload: {
+	headers: { "Content-Type": "application/json" },
+	queryParameters: {},
+	rawBody: { data: null },
+	body: { data: {
+		accountKey: "9384756102938475610",
+		organizerKey: "8456783923409587345",
+		webinarKey: "8978964909939938573",
+		eventKey: "registrant.added",
+		eventName: "registrant.added",
+		eventVersion: "1.0.0",
+		registrantKey: "1234567890",
+		timestamp: "2024-09-01T12:00:00Z"
+	} },
+	pathFragment: "",
+	webhookUrls: {},
+	webhookApiKeys: {},
+	invokeUrl: "",
+	executionId: "RXhhbXBsZUV4ZWN1dGlvblJlc3VsdElk",
+	customer: {
+		id: "testCustomerId",
+		name: "Test Customer",
+		externalId: "testExternalId"
+	},
+	instance: {
+		id: "testInstanceId",
+		name: "Test Instance"
+	},
+	user: {
+		id: "testUserId",
+		email: "user@example.com",
+		name: "Test User",
+		externalId: "testUserExternalId"
+	},
+	integration: {
+		id: "testIntegrationId",
+		name: "Test Integration",
+		versionSequenceId: "1",
+		externalVersion: ""
+	},
+	flow: {
+		id: "testFlowId",
+		name: "Test Flow",
+		stableId: "testFlowStableId"
+	},
+	startedAt: "2024-01-15T00:00:00.000Z",
+	globalDebug: false
+} };
+//#endregion
+//#region src/actions/webinars/index.ts
+var webinars_default = {
+	getWebinars: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Get Webinars",
+			description: "Returns upcoming and past webinars for the currently authenticated organizer that are scheduled within the specified date/time range."
+		},
+		inputs: getWebinarInputs,
+		examplePayload: GET_WEBINARS_EXAMPLE_PAYLOAD,
+		perform: async ({ debug: { enabled: debug } }, { connection, pagination, accountKey, fromTime, toTime, fetchAll }) => {
+			const { client, organizerKey } = createGotoWebinarClient(connection, debug);
+			const url = accountKey ? `/accounts/${accountKey}/webinars` : `/organizers/${organizerKey}/webinars`;
+			if (fetchAll) return { data: await fetchAllResults(client, url, "webinars", {
+				fromTime,
+				toTime
+			}) };
+			const params = {
+				fromTime,
+				toTime,
+				size: pagination.size,
+				page: pagination.page
+			};
+			const { data } = await client.get(url, { params });
+			return { data };
+		}
+	}),
+	cancelWebinar: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Cancel Webinar",
+			description: "Cancels a specific webinar."
+		},
+		inputs: deleteWebinarInputs,
+		examplePayload: DELETE_WEBINAR_EXAMPLE_PAYLOAD,
+		perform: async ({ debug: { enabled: debug } }, { connection, webinarKey, deleteAll, sendCancellationEmail }) => {
+			const { client, organizerKey } = createGotoWebinarClient(connection, debug);
+			const url = `/organizers/${organizerKey}/webinars/${webinarKey}`;
+			const params = {
+				sendCancellationEmail,
+				deleteAll
+			};
+			await client.delete(url, { params });
+			return GENERAL_DELETE_MESSAGE;
+		}
+	}),
+	createWebinar: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Create Webinar",
+			description: "Creates a single session webinar, a sequence of webinars, or a series of webinars."
+		},
+		inputs: createWebinarInputs,
+		examplePayload: CREATE_WEBINAR_EXAMPLE_PAYLOAD,
+		perform: async ({ debug: { enabled: debug } }, { connection, timeZone, times, experienceType, webinarType, emailSettings, additionalFields, subject, description }) => {
+			const { client, organizerKey } = createGotoWebinarClient(connection, debug);
+			const url = `/organizers/${organizerKey}/webinars`;
+			const emailSettingsPayload = {
+				confirmationEmail: emailSettings.confirmationEmail,
+				reminderEmail: emailSettings.reminderEmail,
+				absenteeFollowUpEmail: emailSettings.absenteeFollowUpEmail,
+				attendeeFollowUpEmail: emailSettings.attendeeFollowUpEmail
+			};
+			const payload = {
+				subject,
+				description,
+				times,
+				timeZone,
+				type: webinarType,
+				locale: additionalFields.locale,
+				isPasswordProtected: additionalFields.isPasswordProtected,
+				recordingAssetKey: additionalFields.recordingAssetKey,
+				isOndemand: additionalFields.isOndemand,
+				isBreakout: additionalFields.isBreakout,
+				experienceType,
+				emailSettings: Object.keys(emailSettingsPayload).length > 0 ? emailSettingsPayload : void 0
+			};
+			const { data } = await client.post(url, payload);
+			return { data };
+		}
+	}),
+	updateWebinar: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Update Webinar",
+			description: "Updates a specific webinar."
+		},
+		inputs: updateWebinarInputs,
+		examplePayload: UPDATE_WEBINAR_EXAMPLE_PAYLOAD,
+		perform: async ({ debug: { enabled: debug } }, { subject, emailSettings, times, locale, description, connection, webinarKey, notifyParticipants }) => {
+			const { client, organizerKey } = createGotoWebinarClient(connection, debug);
+			const url = `/organizers/${organizerKey}/webinars/${webinarKey}`;
+			const payload = {
+				subject,
+				description,
+				times,
+				locale,
+				emailSettings: {
+					confirmationEmail: emailSettings.confirmationEmail,
+					reminderEmail: emailSettings.reminderEmail,
+					absenteeFollowUpEmail: emailSettings.absenteeFollowUpEmail,
+					attendeeFollowUpEmail: emailSettings.attendeeFollowUpEmail
+				}
+			};
+			const params = { notifyParticipants };
+			await client.put(url, payload, { params });
+			return GENERAL_DELETE_MESSAGE;
+		}
+	})
+};
+//#endregion
+//#region src/actions/registrants/createRegistrant.ts
+const createRegistrant = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Create Registrant",
+		description: "Register an attendee for a scheduled webinar."
+	},
+	inputs: createRegistrantInputs,
+	examplePayload: CREATE_REGISTRANT_EXAMPLE_PAYLOAD,
+	perform: async ({ debug: { enabled: debug } }, { connection, webinarKey, firstName, lastName, email, phone, mailingAddress, additionalFields, source }) => {
+		const { client, organizerKey } = createGotoWebinarClient(connection, debug);
+		const url = `/organizers/${organizerKey}/webinars/${webinarKey}/registrants`;
+		const payload = {
+			firstName,
+			lastName,
+			email,
+			source,
+			address: mailingAddress.address,
+			city: mailingAddress.city,
+			state: mailingAddress.state,
+			zipCode: mailingAddress.zipCode,
+			country: mailingAddress.country,
+			phone,
+			organization: additionalFields.organization,
+			jobTitle: additionalFields.jobTitle,
+			questionAndComments: additionalFields.questionAndComments,
+			industry: additionalFields.industry,
+			numberOfEmployees: additionalFields.numberOfEmployees,
+			purchasingTimeFrame: additionalFields.purchasingTimeFrame,
+			purchasingRole: additionalFields.purchasingRole,
+			responses: additionalFields.responses
+		};
+		const { data: payloadWithoutParsing } = await client.post(url, payload, { transformResponse: bigIntTransformerConfig.transformResponse });
+		return { data: {
+			...payloadWithoutParsing,
+			registrantKey: parseRegistrantKey(payloadWithoutParsing.registrantKey.c)
+		} };
+	}
+});
+//#endregion
+//#region src/actions/registrants/index.ts
+var registrants_default = {
+	getRegistrant: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Get Registrant",
+			description: "Retrieve registration details for a specific registrant."
+		},
+		inputs: getRegistrantInputs,
+		examplePayload: GET_REGISTRANTS_EXAMPLE_PAYLOAD,
+		perform: async ({ debug: { enabled: debug } }, { connection, webinarKey, registrantKey }) => {
+			const { client, organizerKey } = createGotoWebinarClient(connection, debug);
+			const url = `/organizers/${organizerKey}/webinars/${webinarKey}/registrants/${registrantKey}`;
+			const { data: payloadWithoutParsing } = await client.get(url, { transformResponse: bigIntTransformerConfig.transformResponse });
+			const registrantKeyFromPayload = payloadWithoutParsing.registrantKey.c;
+			return { data: {
+				...payloadWithoutParsing,
+				registrantKey: parseRegistrantKey(registrantKeyFromPayload)
+			} };
+		}
+	}),
+	createRegistrant,
+	deleteRegistrant: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Delete Registrant",
+			description: "Removes a webinar registrant from current registrations for the specified webinar. The webinar must be a scheduled, future webinar."
+		},
+		inputs: deleteRegistrantInputs,
+		examplePayload: GENERAL_DELETE_MESSAGE,
+		perform: async ({ debug: { enabled: debug } }, { connection, webinarKey, registrantKey }) => {
+			const { client, organizerKey } = createGotoWebinarClient(connection, debug);
+			const url = `/organizers/${organizerKey}/webinars/${webinarKey}/registrants/${registrantKey}`;
+			await client.delete(url);
+			return GENERAL_DELETE_MESSAGE;
+		}
+	}),
+	listRegistrants: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "List Registrants",
+			description: "Retrieve registration details for all registrants of a specific webinar."
+		},
+		inputs: listRegistrantsInputs,
+		examplePayload: LIST_REGISTRANTS_EXAMPLE_PAYLOAD,
+		perform: async ({ debug: { enabled: debug } }, { connection, webinarKey, pagination }) => {
+			const { client, organizerKey } = createGotoWebinarClient(connection, debug);
+			const url = `/organizers/${organizerKey}/webinars/${webinarKey}/registrants`;
+			const params = {
+				page: pagination.page,
+				limit: pagination.limit
+			};
+			const { data } = await client.get(url, {
+				params,
+				transformResponse: bigIntTransformerConfig.transformResponse
+			});
+			return { data: data.map((registrant) => ({
+				...registrant,
+				registrantKey: parseRegistrantKey(registrant.registrantKey.c)
+			})) };
+		}
+	})
+};
+//#endregion
+//#region src/actions/attendees/index.ts
+var attendees_default = {
+	listSessionAttendees: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "List Session Attendees",
+			description: "Retrieve details for all attendees of a specific webinar session."
+		},
+		inputs: listSessionAttendeesInputs,
+		examplePayload: LIST_SESSION_ATTENDEES_EXAMPLE_PAYLOAD,
+		perform: async ({ debug: { enabled: debug } }, { connection, webinarKey, sessionKey }) => {
+			const { client, organizerKey } = createGotoWebinarClient(connection, debug);
+			const url = `/organizers/${organizerKey}/webinars/${webinarKey}/sessions/${sessionKey}/attendees`;
+			const { data } = await client.get(url);
+			return { data };
+		}
+	}),
+	listAttendees: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "List Attendees",
+			description: "Retrieve all attendees for all sessions of the specified webinar."
+		},
+		inputs: listAllAttendeesInputs,
+		examplePayload: LIST_ALL_ATTEENDEES_FOR_ALL_WEBINAR_SESSIONS_EXAMPLE_PAYLOAD,
+		perform: async ({ debug: { enabled: debug } }, { connection, webinarKey }) => {
+			const { client, organizerKey } = createGotoWebinarClient(connection, debug);
+			const url = `/organizers/${organizerKey}/webinars/${webinarKey}/performance`;
+			const { data } = await client.get(url);
+			return { data };
+		}
+	}),
+	getAttendee: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Get Attendee",
+			description: "Retrieve registration details for a particular attendee of a specific webinar session."
+		},
+		inputs: getAttendeeInputs,
+		examplePayload: GET_ATTENDEE_EXAMPLE_PAYLOAD,
+		perform: async ({ debug: { enabled: debug } }, { connection, webinarKey, sessionKey, registrantKey }) => {
+			const { client, organizerKey } = createGotoWebinarClient(connection, debug);
+			const url = `/organizers/${organizerKey}/webinars/${webinarKey}/sessions/${sessionKey}/attendees/${registrantKey}`;
+			const { data } = await client.get(url);
+			return { data };
+		}
+	})
+};
+//#endregion
+//#region src/actions/userSubscriptions/index.ts
+var userSubscriptions_default = {
+	getUserSubscription: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Get User Subscription",
+			description: "Retrieve a user subscription by User Subscription Key."
+		},
+		inputs: getUserSubscriptionInputs,
+		examplePayload: GET_USER_SUBSCRIPTION_EXAMPLE_PAYLOAD,
+		perform: async ({ debug: { enabled: debug } }, { connection, userSubscriptionKey }) => {
+			const { client } = createGotoWebinarClient(connection, debug);
+			const url = `/userSubscriptions/${userSubscriptionKey}`;
+			const { data } = await client.get(url);
+			return { data };
+		}
+	}),
+	deleteUserSubscription: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Delete User Subscriptions",
+			description: "Deletes one or more user subscriptions."
+		},
+		inputs: deleteUserSubscriptionInputs,
+		examplePayload: GENERAL_DELETE_MESSAGE,
+		perform: async ({ debug: { enabled: debug } }, { connection, deleteWebhook, userSubscriptionKeys }) => {
+			const { client } = createGotoWebinarClient(connection, debug);
+			if (!deleteWebhook) {
+				await client.delete("/userSubscriptions", { data: userSubscriptionKeys });
+				return GENERAL_DELETE_MESSAGE;
+			}
+			const ids = [];
+			for await (const userSubscriptionKey of userSubscriptionKeys) {
+				const { data: userSubscription } = await client.get(`/userSubscriptions/${userSubscriptionKey}`);
+				ids.push(userSubscription.webhookKey);
+			}
+			await client.delete("/webhooks", { data: ids });
+			return GENERAL_DELETE_MESSAGE;
+		}
+	}),
+	createUserSubscription: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Create User Subscription",
+			description: "Create a new user subscription as a webhook."
+		},
+		inputs: createUserSubscriptionInputs,
+		examplePayload: CREATE_USER_SUBSCRIPTION_EXAMPLE_PAYLOAD,
+		perform: async ({ debug: { enabled: debug } }, { connection, eventVersion, eventName, webhookUrl }) => {
+			const { client } = createGotoWebinarClient(connection, debug);
+			const url = "/webhooks";
+			const payload = [{
+				eventVersion,
+				eventName,
+				callbackUrl: webhookUrl,
+				product: "g2w"
+			}];
+			const { data: { _embedded: { webhooks } } } = await client.post(url, payload);
+			const { webhookKey } = webhooks[0];
+			const { data } = await client.post("/userSubscriptions", [{
+				callbackUrl: webhookUrl,
+				webhookKey,
+				userSubscriptionState: "ACTIVE"
+			}]);
+			return { data };
+		}
+	}),
+	listUserSubscriptions: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "List User Subscriptions",
+			description: "Retrieve a list of user subscriptions."
+		},
+		inputs: listUserSubscriptionsInputs,
+		examplePayload: LIST_USER_SUBSCRIPTIONS_EXAMPLE_PAYLOAD,
+		perform: async ({ debug: { enabled: debug } }, { connection }) => {
+			const { client } = createGotoWebinarClient(connection, debug);
+			const { data } = await client.get("/userSubscriptions", { params: { product: "g2w" } });
+			return { data };
+		}
+	}),
+	updateUserSubscription: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Update User Subscription",
+			description: "Updates an existing user subscription."
+		},
+		inputs: updateUserSubscriptionInputs,
+		examplePayload: GENERAL_DELETE_MESSAGE,
+		perform: async ({ debug: { enabled: debug } }, { connection, userSubscriptionKey, userSubscriptionState, webhookKey, callbackUrl }) => {
+			const { client } = createGotoWebinarClient(connection, debug);
+			const url = "/userSubscriptions";
+			const payload = [{
+				callbackUrl,
+				userSubscriptionKey,
+				userSubscriptionState,
+				webhookKey
+			}];
+			await client.put(url, payload);
+			return GENERAL_DELETE_MESSAGE;
+		}
+	})
+};
+//#endregion
+//#region src/actions/webhooks/index.ts
+var webhooks_default = { deleteInstancedWebhooksAction: (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Delete Instanced Subscriptions",
+		description: "Delete all subscriptions that point to a flow in this instance."
+	},
+	inputs: deleteInstancedWebhooksInputs,
+	examplePayload: GENERAL_DELETE_MESSAGE,
+	perform: async ({ debug: { enabled: debug }, webhookUrls }, { connection }) => {
+		const { client } = createGotoWebinarClient(connection, debug);
+		await deleteInstancedWebhooks(client, Object.values(webhookUrls).map((url) => _prismatic_io_spectral.util.types.toString(url)), { product: "g2w" });
+		return GENERAL_DELETE_MESSAGE;
+	}
+}) };
+//#endregion
+//#region src/actions/misc/rawRequest.ts
+const { debugRequest: _, ...rawRequestInputs } = _prismatic_io_spectral_http.inputs;
+//#endregion
+//#region src/actions/misc/index.ts
+var misc_default = { rawRequest: (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Raw Request",
+		description: "Send a raw HTTP request to GoTo Webinar."
+	},
+	perform: async (context, { connection, ...rawRequestInputs }) => {
+		const { baseUrl, token } = getClientProps(connection);
+		const { data } = await (0, _prismatic_io_spectral_http.sendRawRequest)(baseUrl, {
+			...rawRequestInputs,
+			debugRequest: context.debug.enabled
+		}, {
+			Authorization: token,
+			"Content-Type": "Application/JSON",
+			Accept: "Application/JSON"
+		});
+		return { data: { data } };
+	},
+	inputs: {
+		connection,
+		...rawRequestInputs,
+		url: {
+			...rawRequestInputs.url,
+			comments: "Input the path only (/organizers), The base URL is already included. For example, in order to send a webinar request, only /organizer/{organizerKey}/webinars is entered in this field.",
+			example: "/organizers/{organizerKey}/webinars"
+		}
+	}
+}) };
+//#endregion
+//#region src/actions/index.ts
+var actions_default = {
+	...webinars_default,
+	...registrants_default,
+	...attendees_default,
+	...userSubscriptions_default,
+	...webhooks_default,
+	...misc_default
+};
+//#endregion
+//#region src/dataSources/index.ts
+var dataSources_default = {
+	selectWebinar: (0, _prismatic_io_spectral.dataSource)({
+		display: {
+			label: "Select Webinar",
+			description: "Select a webinar from the list of available webinars by your Account Key."
+		},
+		inputs: {
+			connection,
+			accountKey,
+			fromTime: {
+				...fromTime,
+				required: false,
+				default: getFromTime()
+			},
+			toTime: {
+				...toTime,
+				required: false,
+				default: getEndTime()
+			}
+		},
+		perform: async (context, { connection, accountKey, toTime, fromTime }) => {
+			const { client } = createGotoWebinarClient(connection, false);
+			const url = `/accounts/${accountKey}/webinars`;
+			const params = {
+				fromTime,
+				toTime
+			};
+			const { data } = await client.get(url, { params });
+			const webinars = data._embedded.webinars;
+			if (!webinars) return { result: [] };
+			return { result: webinars.map(({ subject, webinarKey }) => {
+				return {
+					key: webinarKey,
+					label: subject
+				};
+			}) };
+		},
+		dataSourceType: "picklist"
+	}),
+	selectOrganizer: (0, _prismatic_io_spectral.dataSource)({
+		display: {
+			label: "Select Organizer",
+			description: "Select an organizer from the list of available organizer keys."
+		},
+		inputs: {
+			connection,
+			accountKey,
+			fromTime: {
+				...fromTime,
+				required: false,
+				default: getFromTime()
+			},
+			toTime: {
+				...toTime,
+				required: false,
+				default: getEndTime()
+			}
+		},
+		perform: async (context, { connection, accountKey, fromTime, toTime }) => {
+			const { client } = createGotoWebinarClient(connection, false);
+			const url = `/accounts/${accountKey}/webinars`;
+			const params = {
+				fromTime,
+				toTime
+			};
+			const { data } = await client.get(url, { params });
+			const webinars = data._embedded.webinars;
+			if (!webinars) return { result: [] };
+			return { result: webinars.map(({ organizerKey, subject }) => {
+				return {
+					organizerKey,
+					subject
+				};
+			}).filter((value, index, self) => self.indexOf(value) === index).map(({ organizerKey, subject }) => {
+				return {
+					key: organizerKey,
+					label: `Organizer for ${subject}`
+				};
+			}) };
+		},
+		dataSourceType: "picklist"
+	}),
+	selectRegistrant: (0, _prismatic_io_spectral.dataSource)({
+		display: {
+			label: "Select Registrant",
+			description: "Select a registrant from a list of registrants for a webinar."
+		},
+		inputs: {
+			connection,
+			webinarKey: {
+				...webinarKey,
+				dataSource: void 0
+			}
+		},
+		perform: async (context, { connection, webinarKey }) => {
+			const { client, organizerKey } = createGotoWebinarClient(connection, false);
+			const url = `/organizers/${organizerKey}/webinars/${webinarKey}/registrants`;
+			const { data } = await client.get(url, { transformResponse: bigIntTransformerConfig.transformResponse });
+			if (!data || data.length === 0) return { result: [] };
+			return { result: data.map((registrant) => ({
+				key: parseRegistrantKey(registrant.registrantKey.c),
+				label: `${registrant.firstName} ${registrant.lastName} (${registrant.email})`
+			})).sort((a, b) => (a.label ?? "").localeCompare(b.label ?? "")) };
+		},
+		dataSourceType: "picklist"
+	}),
+	selectWebhook: (0, _prismatic_io_spectral.dataSource)({
+		display: {
+			label: "Select Webhook",
+			description: "Select a webhook from a list of available webhooks."
+		},
+		inputs: { connection },
+		perform: async (context, { connection }) => {
+			const { client } = createGotoWebinarClient(connection, false);
+			const { data } = await client.get("/userSubscriptions", { params: { product: "g2w" } });
+			const userSubscriptions = data?._embedded?.userSubscriptions;
+			if (!userSubscriptions) return { result: [] };
+			return { result: userSubscriptions.map(({ eventName, webhookKey, userSubscriptionState }) => {
+				return {
+					key: webhookKey,
+					label: `${webhookKey} - ${eventName} - ${userSubscriptionState}`
+				};
+			}) };
+		},
+		dataSourceType: "picklist"
+	})
+};
+//#endregion
+//#region src/triggers/pollChangesTrigger.ts
+const pollChangesTrigger = (0, _prismatic_io_spectral.pollingTrigger)({
+	display: {
+		label: "New Registrants",
+		description: "Retrieves existing and ongoing registrants for a specified GoTo Webinar webinar. Load history once, check for changes on a schedule, or both."
+	},
+	inputs: {
+		connection,
+		webinarKey,
+		lookBackDate
+	},
+	examplePayload: pollChangesTriggerExamplePayload,
+	triggerResolverSupport: "valid",
+	batchConfig: { batchSize: 50 },
+	triggerResolver: { resolveItems: (_context, { payload }) => resolvePollingRecordChanges(payload.body.data) },
+	perform: async (context, payload, params) => {
+		const pollState = context.polling.getState();
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const lastPolledAt = pollState?.lastPolledAt || (params.lookBackDate ? lookBackDateToCursor(params.lookBackDate) : "");
+		if (!lastPolledAt) {
+			context.polling.setState({ lastPolledAt: now });
+			return {
+				payload: {
+					...payload,
+					body: { data: { created: [] } }
+				},
+				polledNoChanges: true
+			};
+		}
+		const { client, organizerKey } = createGotoWebinarClient(params.connection, context.debug.enabled);
+		const registrants = await fetchAllRegistrants(client, organizerKey, params.webinarKey);
+		const newRegistrants = filterRegistrantsRegisteredAfter(registrants, lastPolledAt);
+		context.polling.setState({ lastPolledAt: now });
+		if (context.debug.enabled) context.logger.debug(`Polled GoToWebinar registrants (webinar ${params.webinarKey}): ${registrants.length} fetched, ${newRegistrants.length} new`);
+		return {
+			payload: {
+				...payload,
+				body: { data: { created: newRegistrants } }
+			},
+			polledNoChanges: newRegistrants.length === 0
+		};
+	}
+});
+//#endregion
+//#region src/triggers/index.ts
+var triggers_default = {
+	userSubscriptionTrigger: (0, _prismatic_io_spectral.trigger)({
+		display: {
+			label: "User Subscription",
+			description: "Receive event notifications from GoTo Webinar. Automatically creates and manages a webhook subscription for the selected event when the instance is deployed, and removes the subscription when the instance is deleted."
+		},
+		inputs: {
+			connection,
+			eventName,
+			eventVersion
+		},
+		examplePayload: userSubscriptionTriggerExamplePayload,
+		webhookLifecycleHandlers: {
+			create: async (context, { connection, eventName, eventVersion }) => {
+				const { client } = createGotoWebinarClient(connection, false);
+				const flowName = context.flow.name;
+				const callbackUrl = context.webhookUrls[flowName];
+				const payload = [{
+					eventVersion,
+					eventName,
+					callbackUrl,
+					product: "g2w"
+				}];
+				const { data: { _embedded: { webhooks } } } = await client.post("/webhooks", payload);
+				const { webhookKey } = webhooks[0];
+				await client.post("/userSubscriptions", [{
+					callbackUrl,
+					webhookKey,
+					userSubscriptionState: "ACTIVE"
+				}]);
+			},
+			delete: async (context, { connection }) => {
+				const { client } = createGotoWebinarClient(connection, false);
+				await deleteInstancedWebhooks(client, Object.values(context.webhookUrls), { product: "g2w" });
+			}
+		},
+		perform: async (context, payload) => {
+			return Promise.resolve({
+				payload,
+				response: {
+					statusCode: 200,
+					contentType: "application/json"
+				}
+			});
+		},
+		synchronousResponseSupport: "invalid",
+		allowsBranching: false,
+		scheduleSupport: "invalid"
+	}),
+	pollChangesTrigger
+};
+//#endregion
+//#region src/index.ts
+var src_default = (0, _prismatic_io_spectral.component)({
+	key: "gotowebinar",
+	public: true,
+	display: {
+		label: "GoTo Webinar",
+		category: "Application Connectors",
+		description: "GoTo Webinar is a platform for hosting, managing, and attending live or pre-recorded webinars.",
+		iconPath: "icon.png"
+	},
+	hooks: { error: _prismatic_io_spectral_http.handleErrors },
+	documentationUrl: "https://prismatic.io/docs/components/gotowebinar/",
+	actions: actions_default,
+	dataSources: dataSources_default,
+	connections: connections_default,
+	triggers: triggers_default
+});
+//#endregion
+//#region npm-dist/.entry.ts
+var _entry_default = (0, _prismatic_io_spectral.callableComponent)(src_default);
+//#endregion
+module.exports = _entry_default;