first commit

packages/nodes-base/nodes/GoToWebinar/GenericFunctions.ts

@@ -0,0 +1,285 @@
+import * as losslessJSON from 'lossless-json';
+import moment from 'moment-timezone';
+import type {
+	IDataObject,
+	IExecuteFunctions,
+	IHookFunctions,
+	IHttpRequestMethods,
+	ILoadOptionsFunctions,
+	INodePropertyOptions,
+	IRequestOptions,
+	JsonObject,
+} from 'n8n-workflow';
+import { NodeApiError } from 'n8n-workflow';
+
+function convertLosslessNumber(_: any, value: any) {
+	if (value?.isLosslessNumber) {
+		return value.toString();
+	} else {
+		return value;
+	}
+}
+
+/**
+ * Make an authenticated API request to GoToWebinar.
+ */
+export async function goToWebinarApiRequest(
+	this: IHookFunctions | IExecuteFunctions | ILoadOptionsFunctions,
+	method: IHttpRequestMethods,
+	endpoint: string,
+	qs: IDataObject,
+	body: IDataObject | IDataObject[],
+	option: IDataObject = {},
+) {
+	const operation = this.getNodeParameter('operation', 0);
+	const resource = this.getNodeParameter('resource', 0);
+
+	const options: IRequestOptions = {
+		headers: {
+			'user-agent': 'n8n',
+			Accept: 'application/json',
+			'Content-Type': 'application/json',
+		},
+		method,
+		uri: `https://api.getgo.com/G2W/rest/v2/${endpoint}`,
+		qs,
+		body: JSON.stringify(body),
+		json: false,
+	};
+
+	if (resource === 'session' && operation === 'getAll') {
+		options.headers!.Accept = 'application/vnd.citrix.g2wapi-v1.1+json';
+	}
+
+	if (['GET', 'DELETE'].includes(method)) {
+		delete options.body;
+	}
+
+	if (!Object.keys(qs).length) {
+		delete options.qs;
+	}
+
+	if (Object.keys(option)) {
+		Object.assign(options, option);
+	}
+
+	try {
+		const response = await this.helpers.requestOAuth2.call(this, 'goToWebinarOAuth2Api', options, {
+			tokenExpiredStatusCode: 403,
+		});
+
+		if (response === '') {
+			return {};
+		}
+
+		// https://stackoverflow.com/questions/62190724/getting-gotowebinar-registrant
+		return losslessJSON.parse(response as string, convertLosslessNumber);
+	} catch (error) {
+		throw new NodeApiError(this.getNode(), error as JsonObject);
+	}
+}
+
+/**
+ * Make an authenticated API request to GoToWebinar and return all results.
+ */
+export async function goToWebinarApiRequestAllItems(
+	this: IHookFunctions | IExecuteFunctions | ILoadOptionsFunctions,
+	method: IHttpRequestMethods,
+	endpoint: string,
+	query: IDataObject,
+	body: IDataObject,
+	resource: string,
+) {
+	const resourceToResponseKey: { [key: string]: string } = {
+		session: 'sessionInfoResources',
+		webinar: 'webinars',
+	};
+
+	const key = resourceToResponseKey[resource];
+
+	let returnData: IDataObject[] = [];
+	let responseData;
+
+	do {
+		responseData = await goToWebinarApiRequest.call(this, method, endpoint, query, body);
+
+		if (responseData.page && parseInt(responseData.page.totalElements as string, 10) === 0) {
+			return [];
+		} else if (responseData._embedded?.[key]) {
+			returnData.push(...(responseData._embedded[key] as IDataObject[]));
+		} else {
+			returnData.push(...(responseData as IDataObject[]));
+		}
+
+		const limit = query.limit as number | undefined;
+		if (limit && returnData.length >= limit) {
+			returnData = returnData.splice(0, limit);
+			return returnData;
+		}
+	} while (
+		responseData.totalElements &&
+		parseInt(responseData.totalElements as string, 10) > returnData.length
+	);
+
+	return returnData;
+}
+
+export async function handleGetAll(
+	this: IExecuteFunctions,
+	endpoint: string,
+	qs: IDataObject,
+	body: IDataObject,
+	resource: string,
+) {
+	const returnAll = this.getNodeParameter('returnAll', 0);
+
+	if (!returnAll) {
+		qs.limit = this.getNodeParameter('limit', 0);
+	}
+
+	return await goToWebinarApiRequestAllItems.call(this, 'GET', endpoint, qs, body, resource);
+}
+
+export async function loadWebinars(this: ILoadOptionsFunctions) {
+	const { oauthTokenData } = await this.getCredentials<{
+		oauthTokenData: { account_key: string };
+	}>('goToWebinarOAuth2Api');
+
+	const endpoint = `accounts/${oauthTokenData.account_key}/webinars`;
+
+	const qs = {
+		fromTime: moment().subtract(1, 'years').format(),
+		toTime: moment().add(1, 'years').format(),
+	};
+
+	const resourceItems = await goToWebinarApiRequestAllItems.call(
+		this,
+		'GET',
+		endpoint,
+		qs,
+		{},
+		'webinar',
+	);
+
+	const returnData: INodePropertyOptions[] = [];
+
+	resourceItems.forEach((item) => {
+		returnData.push({
+			name: item.subject as string,
+			value: item.webinarKey as string,
+		});
+	});
+
+	return returnData;
+}
+
+export async function loadWebinarSessions(this: ILoadOptionsFunctions) {
+	const { oauthTokenData } = await this.getCredentials<{
+		oauthTokenData: { organizer_key: string };
+	}>('goToWebinarOAuth2Api');
+
+	const webinarKey = this.getCurrentNodeParameter('webinarKey') as string;
+
+	const endpoint = `organizers/${oauthTokenData.organizer_key}/webinars/${webinarKey}/sessions`;
+
+	const resourceItems = await goToWebinarApiRequestAllItems.call(
+		this,
+		'GET',
+		endpoint,
+		{},
+		{},
+		'session',
+	);
+
+	const returnData: INodePropertyOptions[] = [];
+
+	resourceItems.forEach((item) => {
+		returnData.push({
+			name: `Date: ${moment(item.startTime as string).format('MM-DD-YYYY')} | From: ${moment(
+				item.startTime as string,
+			).format('LT')} - To: ${moment(item.endTime as string).format('LT')}`,
+			value: item.sessionKey as string,
+		});
+	});
+
+	return returnData;
+}
+
+export async function loadRegistranSimpleQuestions(this: ILoadOptionsFunctions) {
+	const { oauthTokenData } = await this.getCredentials<{
+		oauthTokenData: { organizer_key: string };
+	}>('goToWebinarOAuth2Api');
+
+	const webinarkey = this.getNodeParameter('webinarKey') as string;
+
+	const endpoint = `organizers/${oauthTokenData.organizer_key}/webinars/${webinarkey}/registrants/fields`;
+
+	const { questions } = await goToWebinarApiRequest.call(this, 'GET', endpoint, {}, {});
+
+	const returnData: INodePropertyOptions[] = [];
+
+	questions.forEach((item: IDataObject) => {
+		if (item.type === 'shortAnswer') {
+			returnData.push({
+				name: item.question as string,
+				value: item.questionKey as string,
+			});
+		}
+	});
+
+	return returnData;
+}
+
+export async function loadAnswers(this: ILoadOptionsFunctions) {
+	const { oauthTokenData } = await this.getCredentials<{
+		oauthTokenData: { organizer_key: string };
+	}>('goToWebinarOAuth2Api');
+
+	const webinarKey = this.getCurrentNodeParameter('webinarKey') as string;
+
+	const questionKey = this.getCurrentNodeParameter('questionKey') as string;
+
+	const endpoint = `organizers/${oauthTokenData.organizer_key}/webinars/${webinarKey}/registrants/fields`;
+
+	const { questions } = await goToWebinarApiRequest.call(this, 'GET', endpoint, {}, {});
+
+	const returnData: INodePropertyOptions[] = [];
+
+	questions.forEach((item: IDataObject) => {
+		if (item.type === 'multiChoice' && item.questionKey === questionKey) {
+			for (const answer of item.answers as IDataObject[]) {
+				returnData.push({
+					name: answer.answer as string,
+					value: answer.answerKey as string,
+				});
+			}
+		}
+	});
+
+	return returnData;
+}
+
+export async function loadRegistranMultiChoiceQuestions(this: ILoadOptionsFunctions) {
+	const { oauthTokenData } = await this.getCredentials<{
+		oauthTokenData: { organizer_key: string };
+	}>('goToWebinarOAuth2Api');
+
+	const webinarkey = this.getNodeParameter('webinarKey') as string;
+
+	const endpoint = `organizers/${oauthTokenData.organizer_key}/webinars/${webinarkey}/registrants/fields`;
+
+	const { questions } = await goToWebinarApiRequest.call(this, 'GET', endpoint, {}, {});
+
+	const returnData: INodePropertyOptions[] = [];
+
+	questions.forEach((item: IDataObject) => {
+		if (item.type === 'multipleChoice') {
+			returnData.push({
+				name: item.question as string,
+				value: item.questionKey as string,
+			});
+		}
+	});
+
+	return returnData;
+}

packages/nodes-base/nodes/GoToWebinar/GoToWebinar.node.json

@@ -0,0 +1,18 @@
+{
+	"node": "n8n-nodes-base.goToWebinar",
+	"nodeVersion": "1.0",
+	"codexVersion": "1.0",
+	"categories": ["Communication"],
+	"resources": {
+		"credentialDocumentation": [
+			{
+				"url": "https://docs.n8n.io/integrations/builtin/credentials/gotowebinar/"
+			}
+		],
+		"primaryDocumentation": [
+			{
+				"url": "https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.gotowebinar/"
+			}
+		]
+	}
+}

packages/nodes-base/nodes/GoToWebinar/GoToWebinar.node.ts

@@ -0,0 +1,655 @@
+import isEmpty from 'lodash/isEmpty';
+import omit from 'lodash/omit';
+import moment from 'moment-timezone';
+import { NodeConnectionTypes, NodeOperationError } from 'n8n-workflow';
+import type {
+	IExecuteFunctions,
+	IDataObject,
+	ILoadOptionsFunctions,
+	INodeExecutionData,
+	INodePropertyOptions,
+	INodeType,
+	INodeTypeDescription,
+} from 'n8n-workflow';
+
+import {
+	attendeeFields,
+	attendeeOperations,
+	coorganizerFields,
+	coorganizerOperations,
+	panelistFields,
+	panelistOperations,
+	registrantFields,
+	registrantOperations,
+	sessionFields,
+	sessionOperations,
+	webinarFields,
+	webinarOperations,
+} from './descriptions';
+import {
+	goToWebinarApiRequest,
+	goToWebinarApiRequestAllItems,
+	handleGetAll,
+	loadAnswers,
+	loadRegistranMultiChoiceQuestions,
+	loadRegistranSimpleQuestions,
+	loadWebinars,
+	loadWebinarSessions,
+} from './GenericFunctions';
+
+export class GoToWebinar implements INodeType {
+	description: INodeTypeDescription = {
+		displayName: 'GoToWebinar',
+		name: 'goToWebinar',
+		icon: 'file:gotowebinar.svg',
+		group: ['transform'],
+		version: 1,
+		subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+		description: 'Consume the GoToWebinar API',
+		defaults: {
+			name: 'GoToWebinar',
+		},
+		usableAsTool: true,
+		inputs: [NodeConnectionTypes.Main],
+		outputs: [NodeConnectionTypes.Main],
+		credentials: [
+			{
+				name: 'goToWebinarOAuth2Api',
+				required: true,
+			},
+		],
+		properties: [
+			{
+				displayName: 'Resource',
+				name: 'resource',
+				type: 'options',
+				noDataExpression: true,
+				options: [
+					{
+						name: 'Attendee',
+						value: 'attendee',
+					},
+					{
+						name: 'Co-Organizer',
+						value: 'coorganizer',
+					},
+					{
+						name: 'Panelist',
+						value: 'panelist',
+					},
+					{
+						name: 'Registrant',
+						value: 'registrant',
+					},
+					{
+						name: 'Session',
+						value: 'session',
+					},
+					{
+						name: 'Webinar',
+						value: 'webinar',
+					},
+				],
+				default: 'attendee',
+			},
+			...attendeeOperations,
+			...attendeeFields,
+			...coorganizerOperations,
+			...coorganizerFields,
+			...panelistOperations,
+			...panelistFields,
+			...registrantOperations,
+			...registrantFields,
+			...sessionOperations,
+			...sessionFields,
+			...webinarOperations,
+			...webinarFields,
+		],
+	};
+
+	methods = {
+		loadOptions: {
+			async getWebinars(this: ILoadOptionsFunctions) {
+				return await loadWebinars.call(this);
+			},
+			async getAnswers(this: ILoadOptionsFunctions) {
+				return await loadAnswers.call(this);
+			},
+			async getWebinarSessions(this: ILoadOptionsFunctions) {
+				return await loadWebinarSessions.call(this);
+			},
+			// Get all the timezones to display them to user so that they can
+			// select them easily
+			async getTimezones(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
+				const returnData: INodePropertyOptions[] = [];
+				for (const timezone of moment.tz.names()) {
+					const timezoneName = timezone;
+					const timezoneId = timezone;
+					returnData.push({
+						name: timezoneName,
+						value: timezoneId,
+					});
+				}
+				return returnData;
+			},
+			async getRegistranSimpleQuestions(
+				this: ILoadOptionsFunctions,
+			): Promise<INodePropertyOptions[]> {
+				return await loadRegistranSimpleQuestions.call(this);
+			},
+			async getRegistranMultiChoiceQuestions(
+				this: ILoadOptionsFunctions,
+			): Promise<INodePropertyOptions[]> {
+				return await loadRegistranMultiChoiceQuestions.call(this);
+			},
+		},
+	};
+
+	async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+		const items = this.getInputData();
+
+		const resource = this.getNodeParameter('resource', 0);
+		const operation = this.getNodeParameter('operation', 0);
+
+		let responseData;
+		const returnData: INodeExecutionData[] = [];
+
+		const { oauthTokenData } = await this.getCredentials<{
+			oauthTokenData: { account_key: string; organizer_key: string };
+		}>('goToWebinarOAuth2Api');
+
+		const accountKey = oauthTokenData.account_key;
+		const organizerKey = oauthTokenData.organizer_key;
+
+		for (let i = 0; i < items.length; i++) {
+			try {
+				if (resource === 'attendee') {
+					// *********************************************************************
+					//                            attendee
+					// *********************************************************************
+
+					// https://developer.goto.com/GoToWebinarV2/#tag/Attendees
+
+					if (operation === 'get') {
+						// ----------------------------------
+						//         attendee: get
+						// ----------------------------------
+
+						const webinarKey = this.getNodeParameter('webinarKey', i) as string;
+						const sessionKey = this.getNodeParameter('sessionKey', i) as string;
+						const registrantKey = this.getNodeParameter('registrantKey', i) as string;
+
+						const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/sessions/${sessionKey}/attendees/${registrantKey}`;
+						responseData = await goToWebinarApiRequest.call(this, 'GET', endpoint, {}, {});
+					} else if (operation === 'getAll') {
+						// ----------------------------------
+						//        attendee: getAll
+						// ----------------------------------
+
+						const webinarKey = this.getNodeParameter('webinarKey', i) as string;
+						const sessionKey = this.getNodeParameter('sessionKey', i) as string;
+
+						const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/sessions/${sessionKey}/attendees`;
+						responseData = await handleGetAll.call(this, endpoint, {}, {}, resource);
+					} else if (operation === 'getDetails') {
+						// ----------------------------------
+						//     attendee: getDetails
+						// ----------------------------------
+
+						const webinarKey = this.getNodeParameter('webinarKey', i) as string;
+						const sessionKey = this.getNodeParameter('sessionKey', i) as string;
+						const registrantKey = this.getNodeParameter('registrantKey', i) as string;
+						const details = this.getNodeParameter('details', i) as string;
+
+						const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/sessions/${sessionKey}/attendees/${registrantKey}/${details}`;
+						responseData = await goToWebinarApiRequest.call(this, 'GET', endpoint, {}, {});
+					}
+				} else if (resource === 'coorganizer') {
+					// *********************************************************************
+					//                            coorganizer
+					// *********************************************************************
+
+					// https://developer.goto.com/GoToWebinarV2/#tag/Co-organizers
+
+					if (operation === 'create') {
+						// ----------------------------------
+						//        coorganizer: create
+						// ----------------------------------
+
+						const webinarKey = this.getNodeParameter('webinarKey', i) as string;
+
+						const body = {
+							external: this.getNodeParameter('isExternal', i) as boolean,
+						} as IDataObject;
+
+						if (body.external === false) {
+							body.organizerKey = this.getNodeParameter('organizerKey', i) as string;
+						}
+
+						if (body.external === true) {
+							body.givenName = this.getNodeParameter('givenName', i) as string;
+							body.email = this.getNodeParameter('email', i) as string;
+						}
+
+						const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/coorganizers`;
+						responseData = await goToWebinarApiRequest.call(this, 'POST', endpoint, {}, [body]);
+					} else if (operation === 'delete') {
+						// ----------------------------------
+						//       coorganizer: delete
+						// ----------------------------------
+
+						const webinarKey = this.getNodeParameter('webinarKey', i) as string;
+						const coorganizerKey = this.getNodeParameter('coorganizerKey', i) as string;
+
+						const qs = {
+							external: this.getNodeParameter('isExternal', i) as boolean,
+						};
+
+						const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/coorganizers/${coorganizerKey}`;
+						responseData = await goToWebinarApiRequest.call(this, 'DELETE', endpoint, qs, {});
+						responseData = { success: true };
+					} else if (operation === 'getAll') {
+						// ----------------------------------
+						//        coorganizer: getAll
+						// ----------------------------------
+
+						const webinarKey = this.getNodeParameter('webinarKey', i) as string;
+
+						const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/coorganizers`;
+						responseData = await handleGetAll.call(this, endpoint, {}, {}, resource);
+					} else if (operation === 'reinvite') {
+						// ----------------------------------
+						//       coorganizer: reinvite
+						// ----------------------------------
+
+						const webinarKey = this.getNodeParameter('webinarKey', i) as string;
+						const coorganizerKey = this.getNodeParameter('coorganizerKey', i) as string;
+
+						const qs = {
+							external: this.getNodeParameter('isExternal', i) as boolean,
+						};
+
+						const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/coorganizers/${coorganizerKey}/resendInvitation`;
+
+						responseData = await goToWebinarApiRequest.call(this, 'POST', endpoint, qs, {});
+						responseData = { success: true };
+					}
+				} else if (resource === 'panelist') {
+					// *********************************************************************
+					//                            panelist
+					// *********************************************************************
+
+					// https://developer.goto.com/GoToWebinarV2/#tag/Panelists
+
+					if (operation === 'create') {
+						// ----------------------------------
+						//         panelist: create
+						// ----------------------------------
+
+						const webinarKey = this.getNodeParameter('webinarKey', i) as string;
+
+						const body = [
+							{
+								name: this.getNodeParameter('name', i) as string,
+								email: this.getNodeParameter('email', i) as string,
+							},
+						] as IDataObject[];
+
+						const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/panelists`;
+						responseData = await goToWebinarApiRequest.call(this, 'POST', endpoint, {}, body);
+					} else if (operation === 'delete') {
+						// ----------------------------------
+						//         panelist: delete
+						// ----------------------------------
+
+						const webinarKey = this.getNodeParameter('webinarKey', i) as string;
+						const panelistKey = this.getNodeParameter('panelistKey', i) as string;
+
+						const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/panelists/${panelistKey}`;
+						responseData = await goToWebinarApiRequest.call(this, 'DELETE', endpoint, {}, {});
+						responseData = { success: true };
+					} else if (operation === 'getAll') {
+						// ----------------------------------
+						//         panelist: getAll
+						// ----------------------------------
+
+						const webinarKey = this.getNodeParameter('webinarKey', i) as string;
+
+						const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/panelists`;
+						responseData = await handleGetAll.call(this, endpoint, {}, {}, resource);
+					} else if (operation === 'reinvite') {
+						// ----------------------------------
+						//        panelist: reinvite
+						// ----------------------------------
+
+						const webinarKey = this.getNodeParameter('webinarKey', i) as string;
+						const panelistKey = this.getNodeParameter('panelistKey', i) as string;
+
+						const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/panelists/${panelistKey}/resendInvitation`;
+						responseData = await goToWebinarApiRequest.call(this, 'POST', endpoint, {}, {});
+						responseData = { success: true };
+					}
+				} else if (resource === 'registrant') {
+					// *********************************************************************
+					//                            registrant
+					// *********************************************************************
+
+					// https://developer.goto.com/GoToWebinarV2/#tag/Registrants
+
+					if (operation === 'create') {
+						// ----------------------------------
+						//         registrant: create
+						// ----------------------------------
+
+						const webinarKey = this.getNodeParameter('webinarKey', i) as string;
+
+						const qs = {} as IDataObject;
+						const body = {
+							firstName: this.getNodeParameter('firstName', i) as string,
+							lastName: this.getNodeParameter('lastName', i) as string,
+							email: this.getNodeParameter('email', i) as string,
+							responses: [],
+						} as IDataObject;
+
+						let additionalFields = this.getNodeParameter('additionalFields', i) as Partial<{
+							resendConfirmation: boolean;
+							fullAddress: {
+								details: { [key: string]: string };
+							};
+							simpleResponses: [{ [key: string]: string }];
+							multiChoiceResponses: [{ [key: string]: string }];
+						}>;
+
+						if (additionalFields.resendConfirmation) {
+							qs.resendConfirmation = additionalFields.resendConfirmation;
+							additionalFields = omit(additionalFields, ['resendConfirmation']);
+						}
+
+						if (additionalFields.fullAddress) {
+							Object.assign(body, additionalFields.fullAddress.details);
+							additionalFields = omit(additionalFields, ['fullAddress']);
+						}
+
+						if (additionalFields.simpleResponses) {
+							//@ts-ignore
+							body.responses.push(...additionalFields.simpleResponses.details);
+							additionalFields = omit(additionalFields, ['simpleResponses']);
+						}
+
+						if (additionalFields.multiChoiceResponses) {
+							//@ts-ignore
+							body.responses.push(...additionalFields.multiChoiceResponses.details);
+							additionalFields = omit(additionalFields, ['multiChoiceResponses']);
+						}
+
+						Object.assign(body, additionalFields);
+
+						const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/registrants`;
+						responseData = await goToWebinarApiRequest.call(this, 'POST', endpoint, qs, body);
+					} else if (operation === 'delete') {
+						// ----------------------------------
+						//        registrant: delete
+						// ----------------------------------
+
+						const webinarKey = this.getNodeParameter('webinarKey', i) as string;
+						const registrantKey = this.getNodeParameter('registrantKey', i) as string;
+
+						const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/registrants/${registrantKey}`;
+						responseData = await goToWebinarApiRequest.call(this, 'DELETE', endpoint, {}, {});
+						responseData = { success: true };
+					} else if (operation === 'get') {
+						// ----------------------------------
+						//        registrant: get
+						// ----------------------------------
+
+						const webinarKey = this.getNodeParameter('webinarKey', i) as string;
+						const registrantKey = this.getNodeParameter('registrantKey', i) as string;
+
+						const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/registrants/${registrantKey}`;
+						responseData = await goToWebinarApiRequest.call(this, 'GET', endpoint, {}, {});
+					} else if (operation === 'getAll') {
+						// ----------------------------------
+						//        registrant: getAll
+						// ----------------------------------
+
+						const webinarKey = this.getNodeParameter('webinarKey', i) as string;
+
+						const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/registrants`;
+						responseData = await handleGetAll.call(this, endpoint, {}, {}, resource);
+					}
+				} else if (resource === 'session') {
+					// *********************************************************************
+					//                              session
+					// *********************************************************************
+
+					// https://developer.goto.com/GoToWebinarV2/#tag/Sessions
+
+					if (operation === 'get') {
+						// ----------------------------------
+						//         session: get
+						// ----------------------------------
+
+						const webinarKey = this.getNodeParameter('webinarKey', i) as string;
+						const sessionKey = this.getNodeParameter('sessionKey', i) as string;
+
+						const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/sessions/${sessionKey}`;
+						responseData = await goToWebinarApiRequest.call(this, 'GET', endpoint, {}, {});
+					} else if (operation === 'getAll') {
+						// ----------------------------------
+						//         session: getAll
+						// ----------------------------------
+
+						const qs = {} as IDataObject;
+
+						const returnAll = this.getNodeParameter('returnAll', 0);
+
+						if (!returnAll) {
+							qs.limit = this.getNodeParameter('limit', 0);
+						}
+
+						const { webinarKey, times } = this.getNodeParameter('additionalFields', i) as {
+							filterByWebinar: boolean;
+							webinarKey: string;
+							times: {
+								timesProperties: { [key: string]: string };
+							};
+						};
+
+						if (times) {
+							qs.fromTime = moment(times.timesProperties.fromTime).format();
+							qs.toTime = moment(times.timesProperties.toTime).format();
+						} else {
+							qs.fromTime = moment().subtract(1, 'years').format();
+							qs.toTime = moment().format();
+						}
+
+						if (webinarKey !== undefined) {
+							const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/sessions`;
+							responseData = await goToWebinarApiRequestAllItems.call(
+								this,
+								'GET',
+								endpoint,
+								qs,
+								{},
+								resource,
+							);
+						} else {
+							const endpoint = `organizers/${organizerKey}/sessions`;
+							responseData = await goToWebinarApiRequestAllItems.call(
+								this,
+								'GET',
+								endpoint,
+								qs,
+								{},
+								resource,
+							);
+						}
+					} else if (operation === 'getDetails') {
+						// ----------------------------------
+						//         session: getDetails
+						// ----------------------------------
+
+						const webinarKey = this.getNodeParameter('webinarKey', i) as string;
+						const sessionKey = this.getNodeParameter('sessionKey', i) as string;
+						const details = this.getNodeParameter('details', i) as string;
+
+						const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/sessions/${sessionKey}/${details}`;
+						responseData = await goToWebinarApiRequest.call(this, 'GET', endpoint, {}, {});
+					}
+				} else if (resource === 'webinar') {
+					// *********************************************************************
+					//                               webinar
+					// *********************************************************************
+
+					// https://developer.goto.com/GoToWebinarV2/#tag/Webinars
+
+					if (operation === 'create') {
+						// ----------------------------------
+						//         webinar: create
+						// ----------------------------------
+
+						const timesProperties = this.getNodeParameter(
+							'times.timesProperties',
+							i,
+							[],
+						) as IDataObject;
+
+						const body = {
+							subject: this.getNodeParameter('subject', i) as string,
+							times: timesProperties,
+						} as IDataObject;
+
+						const additionalFields = this.getNodeParameter('additionalFields', i);
+						Object.assign(body, additionalFields);
+
+						const endpoint = `organizers/${organizerKey}/webinars`;
+						responseData = await goToWebinarApiRequest.call(this, 'POST', endpoint, {}, body);
+					} else if (operation === 'delete') {
+						// ----------------------------------
+						//         webinar: delete
+						// ----------------------------------
+
+						const webinarKey = this.getNodeParameter('webinarKey', i) as string;
+
+						const { sendCancellationEmails } = this.getNodeParameter('additionalFields', i);
+
+						const qs = {} as IDataObject;
+
+						if (sendCancellationEmails) {
+							qs.sendCancellationEmails = sendCancellationEmails;
+						}
+
+						const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}`;
+						await goToWebinarApiRequest.call(this, 'DELETE', endpoint, qs, {});
+						responseData = { success: true };
+					} else if (operation === 'get') {
+						// ----------------------------------
+						//         webinar: get
+						// ----------------------------------
+
+						const webinarKey = this.getNodeParameter('webinarKey', i) as string;
+
+						const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}`;
+						responseData = await goToWebinarApiRequest.call(this, 'GET', endpoint, {}, {});
+					} else if (operation === 'getAll') {
+						// ----------------------------------
+						//         webinar: getAll
+						// ----------------------------------
+
+						const qs = {} as IDataObject;
+
+						const returnAll = this.getNodeParameter('returnAll', 0);
+
+						if (!returnAll) {
+							qs.limit = this.getNodeParameter('limit', 0);
+						}
+
+						const { times } = this.getNodeParameter('additionalFields', i) as {
+							times: {
+								timesProperties: { [key: string]: string };
+							};
+						};
+
+						if (times) {
+							qs.fromTime = moment(times.timesProperties.fromTime).format();
+							qs.toTime = moment(times.timesProperties.toTime).format();
+						} else {
+							qs.fromTime = moment().subtract(1, 'years').format();
+							qs.toTime = moment().format();
+						}
+
+						const endpoint = `accounts/${accountKey}/webinars`;
+						responseData = await goToWebinarApiRequestAllItems.call(
+							this,
+							'GET',
+							endpoint,
+							qs,
+							{},
+							resource,
+						);
+					} else if (operation === 'update') {
+						// ----------------------------------
+						//         webinar: update
+						// ----------------------------------
+
+						const webinarKey = this.getNodeParameter('webinarKey', i) as string;
+
+						const qs = {
+							notifyParticipants: this.getNodeParameter('notifyParticipants', i) as boolean,
+						} as IDataObject;
+
+						let body = {};
+
+						let updateFields = this.getNodeParameter('updateFields', i);
+
+						if (updateFields.times) {
+							const { times } = updateFields as {
+								times: { timesProperties: Array<{ startTime: string; endTime: string }> };
+							};
+
+							body = {
+								times: times.timesProperties,
+							} as IDataObject;
+
+							updateFields = omit(updateFields, ['times']);
+						}
+
+						Object.assign(body, updateFields);
+
+						if (isEmpty(updateFields)) {
+							throw new NodeOperationError(
+								this.getNode(),
+								`Please enter at least one field to update for the ${resource}.`,
+								{ itemIndex: i },
+							);
+						}
+
+						const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}`;
+						await goToWebinarApiRequest.call(this, 'PUT', endpoint, qs, body);
+						responseData = { success: true };
+					}
+				}
+			} catch (error) {
+				if (this.continueOnFail()) {
+					const executionErrorData = this.helpers.constructExecutionMetaData(
+						this.helpers.returnJsonArray({ error: error.message }),
+						{ itemData: { item: i } },
+					);
+					returnData.push(...executionErrorData);
+					continue;
+				}
+
+				throw error;
+			}
+
+			const executionData = this.helpers.constructExecutionMetaData(
+				this.helpers.returnJsonArray(responseData as IDataObject[]),
+				{ itemData: { item: i } },
+			);
+
+			returnData.push(...executionData);
+		}
+
+		return [returnData];
+	}
+}

packages/nodes-base/nodes/GoToWebinar/descriptions/AttendeeDescription.ts

@@ -0,0 +1,176 @@
+import type { INodeProperties } from 'n8n-workflow';
+
+export const attendeeOperations: INodeProperties[] = [
+	{
+		displayName: 'Operation',
+		name: 'operation',
+		type: 'options',
+		noDataExpression: true,
+		default: 'get',
+		options: [
+			{
+				name: 'Get',
+				value: 'get',
+				action: 'Get an attendee',
+			},
+			{
+				name: 'Get Many',
+				value: 'getAll',
+				action: 'Get many attendees',
+			},
+			{
+				name: 'Get Details',
+				value: 'getDetails',
+				action: 'Get details of an attendee',
+			},
+		],
+		displayOptions: {
+			show: {
+				resource: ['attendee'],
+			},
+		},
+	},
+];
+
+export const attendeeFields: INodeProperties[] = [
+	// ----------------------------------
+	//     attendee: shared fields
+	// ----------------------------------
+	{
+		displayName: 'Webinar Key Name or ID',
+		name: 'webinarKey',
+		type: 'options',
+		typeOptions: {
+			loadOptionsMethod: 'getWebinars',
+		},
+		required: true,
+		default: '',
+		description:
+			'Key of the webinar that the attendee attended. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+		displayOptions: {
+			show: {
+				resource: ['attendee'],
+			},
+		},
+	},
+	{
+		displayName: 'Session Key Name or ID',
+		name: 'sessionKey',
+		type: 'options',
+		required: true,
+		typeOptions: {
+			loadOptionsMethod: 'getWebinarSessions',
+			loadOptionsDependsOn: ['webinarKey'],
+		},
+		default: '',
+		description:
+			'Key of the session that the attendee attended. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+		displayOptions: {
+			show: {
+				resource: ['attendee'],
+			},
+		},
+	},
+
+	// ----------------------------------
+	//          attendee: get
+	// ----------------------------------
+	{
+		displayName: 'Registrant Key',
+		name: 'registrantKey',
+		type: 'string',
+		required: true,
+		default: '',
+		description: 'Registrant key of the attendee at the webinar session',
+		displayOptions: {
+			show: {
+				resource: ['attendee'],
+				operation: ['get'],
+			},
+		},
+	},
+
+	// ----------------------------------
+	//       attendee: getDetails
+	// ----------------------------------
+	{
+		displayName: 'Registrant Key',
+		name: 'registrantKey',
+		type: 'string',
+		required: true,
+		default: '',
+		description: 'Registrant key of the attendee at the webinar session',
+		displayOptions: {
+			show: {
+				resource: ['attendee'],
+				operation: ['getDetails'],
+			},
+		},
+	},
+	{
+		displayName: 'Details',
+		name: 'details',
+		type: 'options',
+		required: true,
+		default: '',
+		description: 'The details to retrieve for the attendee',
+		options: [
+			{
+				name: 'Polls',
+				value: 'polls',
+				description: 'Poll answers from the attendee in a webinar session',
+			},
+			{
+				name: 'Questions',
+				value: 'questions',
+				description: 'Questions asked by the attendee in a webinar session',
+			},
+			{
+				name: 'Survey Answers',
+				value: 'surveyAnswers',
+				description: 'Survey answers from the attendee in a webinar session',
+			},
+		],
+		displayOptions: {
+			show: {
+				resource: ['attendee'],
+				operation: ['getDetails'],
+			},
+		},
+	},
+
+	// ----------------------------------
+	//         attendee: getAll
+	// ----------------------------------
+	{
+		displayName: 'Return All',
+		name: 'returnAll',
+		type: 'boolean',
+		default: false,
+		description: 'Whether to return all results or only up to a given limit',
+		displayOptions: {
+			show: {
+				resource: ['attendee'],
+				operation: ['getAll'],
+			},
+		},
+	},
+	{
+		displayName: 'Limit',
+		name: 'limit',
+		type: 'number',
+		default: 10,
+		description: 'Max number of results to return',
+		typeOptions: {
+			minValue: 1,
+			maxValue: 100,
+		},
+		displayOptions: {
+			show: {
+				resource: ['attendee'],
+				operation: ['getAll'],
+				returnAll: [false],
+			},
+		},
+	},
+];

packages/nodes-base/nodes/GoToWebinar/descriptions/CoorganizerDescription.ts

@@ -0,0 +1,269 @@
+import type { INodeProperties } from 'n8n-workflow';
+
+export const coorganizerOperations: INodeProperties[] = [
+	{
+		displayName: 'Operation',
+		name: 'operation',
+		type: 'options',
+		noDataExpression: true,
+		default: 'get',
+		options: [
+			{
+				name: 'Create',
+				value: 'create',
+				action: 'Create a coorganizer',
+			},
+			{
+				name: 'Delete',
+				value: 'delete',
+				action: 'Delete a coorganizer',
+			},
+			{
+				name: 'Get Many',
+				value: 'getAll',
+				action: 'Get many coorganizers',
+			},
+			{
+				name: 'Reinvite',
+				value: 'reinvite',
+				action: 'Reinvite a coorganizer',
+			},
+		],
+		displayOptions: {
+			show: {
+				resource: ['coorganizer'],
+			},
+		},
+	},
+];
+
+export const coorganizerFields: INodeProperties[] = [
+	// ----------------------------------
+	//         coorganizer: create
+	// ----------------------------------
+	{
+		displayName: 'Webinar Key Name or ID',
+		name: 'webinarKey',
+		type: 'options',
+		typeOptions: {
+			loadOptionsMethod: 'getWebinars',
+		},
+		required: true,
+		default: [],
+		description:
+			'Key of the webinar that the co-organizer is hosting. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+		displayOptions: {
+			show: {
+				resource: ['coorganizer'],
+				operation: ['create'],
+			},
+		},
+	},
+	{
+		displayName: 'Is External',
+		name: 'isExternal',
+		type: 'boolean',
+		required: true,
+		default: false,
+		description: 'Whether the co-organizer has no GoToWebinar account',
+		displayOptions: {
+			show: {
+				resource: ['coorganizer'],
+				operation: ['create'],
+			},
+		},
+	},
+	{
+		displayName: 'Organizer Key',
+		name: 'organizerKey',
+		type: 'string',
+		default: '',
+		description: "The co-organizer's organizer key for the webinar",
+		displayOptions: {
+			show: {
+				resource: ['coorganizer'],
+				operation: ['create'],
+				isExternal: [false],
+			},
+		},
+	},
+	{
+		displayName: 'Given Name',
+		name: 'givenName',
+		type: 'string',
+		default: '',
+		description: "The co-organizer's given name",
+		displayOptions: {
+			show: {
+				resource: ['coorganizer'],
+				operation: ['create'],
+				isExternal: [true],
+			},
+		},
+	},
+	{
+		displayName: 'Email',
+		name: 'email',
+		type: 'string',
+		placeholder: 'name@email.com',
+		default: '',
+		description: "The co-organizer's email address",
+		displayOptions: {
+			show: {
+				resource: ['coorganizer'],
+				operation: ['create'],
+				isExternal: [true],
+			},
+		},
+	},
+
+	// ----------------------------------
+	//         coorganizer: delete
+	// ----------------------------------
+	{
+		displayName: 'Webinar Key Name or ID',
+		name: 'webinarKey',
+		type: 'options',
+		typeOptions: {
+			loadOptionsMethod: 'getWebinars',
+		},
+		required: true,
+		default: [],
+		description:
+			'Key of the webinar to delete. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+		displayOptions: {
+			show: {
+				resource: ['coorganizer'],
+				operation: ['delete'],
+			},
+		},
+	},
+	{
+		displayName: 'Co-Organizer Key',
+		name: 'coorganizerKey',
+		type: 'string',
+		default: '',
+		description: 'Key of the co-organizer to delete',
+		displayOptions: {
+			show: {
+				resource: ['coorganizer'],
+				operation: ['delete'],
+			},
+		},
+	},
+	{
+		displayName: 'Is External',
+		name: 'isExternal',
+		type: 'boolean',
+		required: true,
+		default: false,
+		displayOptions: {
+			show: {
+				resource: ['coorganizer'],
+				operation: ['delete'],
+			},
+		},
+		// eslint-disable-next-line n8n-nodes-base/node-param-description-boolean-without-whether
+		description:
+			"By default only internal co-organizers (with a GoToWebinar account) can be deleted. If you want to use this call for external co-organizers you have to set this parameter to 'true'.",
+	},
+
+	// ----------------------------------
+	//        coorganizer: getAll
+	// ----------------------------------
+	{
+		displayName: 'Webinar Key Name or ID',
+		name: 'webinarKey',
+		type: 'options',
+		typeOptions: {
+			loadOptionsMethod: 'getWebinars',
+		},
+		required: true,
+		default: [],
+		description:
+			'Key of the webinar to retrieve all co-organizers from. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+		displayOptions: {
+			show: {
+				resource: ['coorganizer'],
+				operation: ['getAll'],
+			},
+		},
+	},
+	{
+		displayName: 'Return All',
+		name: 'returnAll',
+		type: 'boolean',
+		default: false,
+		description: 'Whether to return all results or only up to a given limit',
+		displayOptions: {
+			show: {
+				resource: ['coorganizer'],
+				operation: ['getAll'],
+			},
+		},
+	},
+	{
+		displayName: 'Limit',
+		name: 'limit',
+		type: 'number',
+		default: 10,
+		description: 'Max number of results to return',
+		typeOptions: {
+			minValue: 1,
+			maxValue: 100,
+		},
+		displayOptions: {
+			show: {
+				resource: ['coorganizer'],
+				operation: ['getAll'],
+				returnAll: [false],
+			},
+		},
+	},
+
+	// ----------------------------------
+	//      coorganizer: reinvite
+	// ----------------------------------
+	{
+		displayName: 'Webinar Key',
+		name: 'webinarKey',
+		type: 'string',
+		required: true,
+		default: '',
+		description:
+			"By default only internal co-organizers (with a GoToWebinar account) can be deleted. If you want to use this call for external co-organizers you have to set this parameter to 'true'.",
+		displayOptions: {
+			show: {
+				resource: ['coorganizer'],
+				operation: ['reinvite'],
+			},
+		},
+	},
+	{
+		displayName: 'Co-Organizer Key',
+		name: 'coorganizerKey',
+		type: 'string',
+		default: '',
+		description: 'Key of the co-organizer to reinvite',
+		displayOptions: {
+			show: {
+				resource: ['coorganizer'],
+				operation: ['reinvite'],
+			},
+		},
+	},
+	{
+		displayName: 'Is External',
+		name: 'isExternal',
+		type: 'boolean',
+		required: true,
+		default: false,
+		description: 'Whether the co-organizer has no GoToWebinar account',
+		displayOptions: {
+			show: {
+				resource: ['coorganizer'],
+				operation: ['reinvite'],
+			},
+		},
+	},
+];

packages/nodes-base/nodes/GoToWebinar/descriptions/PanelistDescription.ts

@@ -0,0 +1,216 @@
+import type { INodeProperties } from 'n8n-workflow';
+
+export const panelistOperations: INodeProperties[] = [
+	{
+		displayName: 'Operation',
+		name: 'operation',
+		type: 'options',
+		noDataExpression: true,
+		default: 'get',
+		options: [
+			{
+				name: 'Create',
+				value: 'create',
+				action: 'Create a panelist',
+			},
+			{
+				name: 'Delete',
+				value: 'delete',
+				action: 'Delete a panelist',
+			},
+			{
+				name: 'Get Many',
+				value: 'getAll',
+				action: 'Get many panelists',
+			},
+			{
+				name: 'Reinvite',
+				value: 'reinvite',
+				action: 'Reinvite a panelist',
+			},
+		],
+		displayOptions: {
+			show: {
+				resource: ['panelist'],
+			},
+		},
+	},
+];
+
+export const panelistFields: INodeProperties[] = [
+	// ----------------------------------
+	//        panelist: create
+	// ----------------------------------
+	{
+		displayName: 'Name',
+		name: 'name',
+		type: 'string',
+		required: true,
+		default: '',
+		description: 'Name of the panelist to create',
+		displayOptions: {
+			show: {
+				resource: ['panelist'],
+				operation: ['create'],
+			},
+		},
+	},
+	{
+		displayName: 'Email',
+		name: 'email',
+		type: 'string',
+		placeholder: 'name@email.com',
+		required: true,
+		default: '',
+		description: 'Email address of the panelist to create',
+		displayOptions: {
+			show: {
+				resource: ['panelist'],
+				operation: ['create'],
+			},
+		},
+	},
+	{
+		displayName: 'Webinar Key Name or ID',
+		name: 'webinarKey',
+		type: 'options',
+		typeOptions: {
+			loadOptionsMethod: 'getWebinars',
+		},
+		required: true,
+		default: [],
+		description:
+			'Key of the webinar that the panelist will present at. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+		displayOptions: {
+			show: {
+				resource: ['panelist'],
+				operation: ['create'],
+			},
+		},
+	},
+
+	// ----------------------------------
+	//        panelist: getAll
+	// ----------------------------------
+	{
+		displayName: 'Webinar Key Name or ID',
+		name: 'webinarKey',
+		type: 'options',
+		typeOptions: {
+			loadOptionsMethod: 'getWebinars',
+		},
+		required: true,
+		default: [],
+		description:
+			'Key of the webinar to retrieve all panelists from. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+		displayOptions: {
+			show: {
+				resource: ['panelist'],
+				operation: ['getAll'],
+			},
+		},
+	},
+	{
+		displayName: 'Return All',
+		name: 'returnAll',
+		type: 'boolean',
+		default: false,
+		description: 'Whether to return all results or only up to a given limit',
+		displayOptions: {
+			show: {
+				resource: ['panelist'],
+				operation: ['getAll'],
+			},
+		},
+	},
+	{
+		displayName: 'Limit',
+		name: 'limit',
+		type: 'number',
+		default: 10,
+		description: 'Max number of results to return',
+		typeOptions: {
+			minValue: 1,
+			maxValue: 100,
+		},
+		displayOptions: {
+			show: {
+				resource: ['panelist'],
+				operation: ['getAll'],
+				returnAll: [false],
+			},
+		},
+	},
+
+	// ----------------------------------
+	//        panelist: delete
+	// ----------------------------------
+	{
+		displayName: 'Webinar Key Name or ID',
+		name: 'webinarKey',
+		type: 'options',
+		typeOptions: {
+			loadOptionsMethod: 'getWebinars',
+		},
+		required: true,
+		default: [],
+		description:
+			'Key of the webinar to delete the panelist from. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+		displayOptions: {
+			show: {
+				resource: ['panelist'],
+				operation: ['delete'],
+			},
+		},
+	},
+	{
+		displayName: 'Panelist Key',
+		name: 'panelistKey',
+		type: 'string',
+		required: true,
+		default: '',
+		description: 'Key of the panelist to delete',
+		displayOptions: {
+			show: {
+				resource: ['panelist'],
+				operation: ['delete'],
+			},
+		},
+	},
+
+	// ----------------------------------
+	//        panelist: reinvite
+	// ----------------------------------
+	{
+		displayName: 'Webinar Key Name or ID',
+		name: 'webinarKey',
+		type: 'options',
+		typeOptions: {
+			loadOptionsMethod: 'getWebinars',
+		},
+		required: true,
+		default: [],
+		description:
+			'Key of the webinar to reinvite the panelist to. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+		displayOptions: {
+			show: {
+				resource: ['panelist'],
+				operation: ['reinvite'],
+			},
+		},
+	},
+	{
+		displayName: 'Panelist Key',
+		name: 'panelistKey',
+		type: 'string',
+		required: true,
+		default: '',
+		description: 'Key of the panelist to reinvite',
+		displayOptions: {
+			show: {
+				resource: ['panelist'],
+				operation: ['reinvite'],
+			},
+		},
+	},
+];

packages/nodes-base/nodes/GoToWebinar/descriptions/RegistrantDescription.ts

@@ -0,0 +1,430 @@
+import type { INodeProperties } from 'n8n-workflow';
+
+export const registrantOperations: INodeProperties[] = [
+	{
+		displayName: 'Operation',
+		name: 'operation',
+		type: 'options',
+		noDataExpression: true,
+		default: 'get',
+		options: [
+			{
+				name: 'Create',
+				value: 'create',
+				action: 'Create a registrant',
+			},
+			{
+				name: 'Delete',
+				value: 'delete',
+				action: 'Delete a registrant',
+			},
+			{
+				name: 'Get',
+				value: 'get',
+				action: 'Get a registrant',
+			},
+			{
+				name: 'Get Many',
+				value: 'getAll',
+				action: 'Get many registrants',
+			},
+		],
+		displayOptions: {
+			show: {
+				resource: ['registrant'],
+			},
+		},
+	},
+];
+
+export const registrantFields: INodeProperties[] = [
+	// ----------------------------------
+	//         registrant: create
+	// ----------------------------------
+	{
+		displayName: 'Webinar Key Name or ID',
+		name: 'webinarKey',
+		type: 'options',
+		typeOptions: {
+			loadOptionsMethod: 'getWebinars',
+		},
+		required: true,
+		default: [],
+		description:
+			'Key of the webinar of the registrant to create. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+		displayOptions: {
+			show: {
+				resource: ['registrant'],
+				operation: ['create'],
+			},
+		},
+	},
+	{
+		displayName: 'First Name',
+		name: 'firstName',
+		type: 'string',
+		default: '',
+		description: 'First name of the registrant to create',
+		displayOptions: {
+			show: {
+				resource: ['registrant'],
+				operation: ['create'],
+			},
+		},
+	},
+	{
+		displayName: 'Last Name',
+		name: 'lastName',
+		type: 'string',
+		default: '',
+		description: 'Last name of the registrant to create',
+		displayOptions: {
+			show: {
+				resource: ['registrant'],
+				operation: ['create'],
+			},
+		},
+	},
+	{
+		displayName: 'Email',
+		name: 'email',
+		type: 'string',
+		placeholder: 'name@email.com',
+		default: '',
+		description: 'Email address of the registrant to create',
+		displayOptions: {
+			show: {
+				resource: ['registrant'],
+				operation: ['create'],
+			},
+		},
+	},
+	{
+		displayName: 'Additional Fields',
+		name: 'additionalFields',
+		type: 'collection',
+		placeholder: 'Add Field',
+		displayOptions: {
+			show: {
+				resource: ['registrant'],
+				operation: ['create'],
+			},
+		},
+		default: {},
+		options: [
+			{
+				displayName: 'Full Address',
+				name: 'fullAddress',
+				placeholder: 'Add Address Fields',
+				type: 'fixedCollection',
+				description: 'Full address of the registrant to create',
+				default: {},
+				options: [
+					{
+						displayName: 'Details',
+						name: 'details',
+						values: [
+							{
+								displayName: 'Address',
+								name: 'address',
+								type: 'string',
+								default: '',
+							},
+							{
+								displayName: 'City',
+								name: 'city',
+								type: 'string',
+								default: '',
+							},
+							{
+								displayName: 'State',
+								name: 'state',
+								type: 'string',
+								default: '',
+							},
+							{
+								displayName: 'Zip Code',
+								name: 'zipCode',
+								type: 'string',
+								default: '',
+							},
+							{
+								displayName: 'Country',
+								name: 'country',
+								type: 'string',
+								default: '',
+							},
+						],
+					},
+				],
+			},
+			{
+				displayName: 'Industry',
+				name: 'industry',
+				type: 'string',
+				default: '',
+				description: "The type of industry the registrant's organization belongs to",
+			},
+			{
+				displayName: 'Job Title',
+				name: 'jobTitle',
+				type: 'string',
+				default: '',
+			},
+			{
+				displayName: 'MultiChoice Responses',
+				name: 'multiChoiceResponses',
+				placeholder: 'Add MultiChoice Response',
+				type: 'fixedCollection',
+				typeOptions: {
+					multipleValues: true,
+				},
+				description: 'Set the answers to all questions',
+				default: {},
+				options: [
+					{
+						displayName: 'Details',
+						name: 'details',
+						values: [
+							{
+								displayName: 'Question Key Name or ID',
+								name: 'questionKey',
+								type: 'options',
+								description:
+									'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>',
+								typeOptions: {
+									loadOptionsMethod: 'getRegistranMultiChoiceQuestions',
+									loadOptionsDependsOn: ['webinarKey'],
+								},
+								default: '',
+							},
+							{
+								displayName: 'Answer Key',
+								name: 'AnswerKey',
+								type: 'string',
+								default: '',
+								description: 'Answer ID of the question',
+							},
+						],
+					},
+				],
+			},
+			{
+				displayName: 'Number of Employees',
+				name: 'numberOfEmployees',
+				type: 'string',
+				default: '',
+				description: "The size in employees of the registrant's organization",
+			},
+			{
+				displayName: 'Organization',
+				name: 'organization',
+				type: 'string',
+				default: '',
+			},
+			{
+				displayName: 'Telephone',
+				name: 'phone',
+				type: 'string',
+				default: '',
+			},
+			{
+				displayName: 'Purchasing Role',
+				name: 'purchasingRole',
+				type: 'string',
+				default: '',
+				description: "Registrant's role in purchasing the product",
+			},
+			{
+				displayName: 'Purchasing Time Frame',
+				name: 'purchasingTimeFrame',
+				type: 'string',
+				default: '',
+				description: 'Time frame within which the product will be purchased',
+			},
+			{
+				displayName: 'Questions and Comments',
+				name: 'questionsAndComments',
+				type: 'string',
+				default: '',
+				description: 'Questions or comments made by the registrant during registration',
+			},
+			{
+				displayName: 'Resend Confirmation',
+				name: 'resendConfirmation',
+				type: 'boolean',
+				default: false,
+			},
+			{
+				displayName: 'Simple Responses',
+				name: 'simpleResponses',
+				placeholder: 'Add Simple Response',
+				type: 'fixedCollection',
+				typeOptions: {
+					multipleValues: true,
+				},
+				description: 'Set the answers to all questions',
+				default: {},
+				options: [
+					{
+						displayName: 'Details',
+						name: 'details',
+						values: [
+							{
+								displayName: 'Question Key Name or ID',
+								name: 'questionKey',
+								type: 'options',
+								description:
+									'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>',
+								typeOptions: {
+									loadOptionsMethod: 'getRegistranSimpleQuestions',
+									loadOptionsDependsOn: ['webinarKey'],
+								},
+								default: '',
+							},
+							{
+								displayName: 'Response Text',
+								name: 'responseText',
+								type: 'string',
+								default: '',
+								description: 'Text of the response to the question',
+							},
+						],
+					},
+				],
+			},
+			{
+				displayName: 'Source',
+				name: 'source',
+				type: 'string',
+				default: '',
+				description: 'The source that led to the registration',
+			},
+		],
+	},
+
+	// ----------------------------------
+	//        registrant: getAll
+	// ----------------------------------
+	{
+		displayName: 'Webinar Key Name or ID',
+		name: 'webinarKey',
+		type: 'options',
+		typeOptions: {
+			loadOptionsMethod: 'getWebinars',
+		},
+		required: true,
+		default: [],
+		description:
+			'The key of the webinar to retrieve registrants from. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+		displayOptions: {
+			show: {
+				resource: ['registrant'],
+				operation: ['getAll'],
+			},
+		},
+	},
+	{
+		displayName: 'Return All',
+		name: 'returnAll',
+		type: 'boolean',
+		default: false,
+		description: 'Whether to return all results or only up to a given limit',
+		displayOptions: {
+			show: {
+				resource: ['registrant'],
+				operation: ['getAll'],
+			},
+		},
+	},
+	{
+		displayName: 'Limit',
+		name: 'limit',
+		type: 'number',
+		default: 10,
+		description: 'Max number of results to return',
+		typeOptions: {
+			minValue: 1,
+			maxValue: 100,
+		},
+		displayOptions: {
+			show: {
+				resource: ['registrant'],
+				operation: ['getAll'],
+				returnAll: [false],
+			},
+		},
+	},
+
+	// ----------------------------------
+	//         registrant: delete
+	// ----------------------------------
+	{
+		displayName: 'Webinar Key Name or ID',
+		name: 'webinarKey',
+		type: 'options',
+		typeOptions: {
+			loadOptionsMethod: 'getWebinars',
+		},
+		required: true,
+		default: [],
+		description:
+			'Key of the webinar of the registrant to delete. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+		displayOptions: {
+			show: {
+				resource: ['registrant'],
+				operation: ['delete'],
+			},
+		},
+	},
+	{
+		displayName: 'Registrant Key',
+		name: 'registrantKey',
+		type: 'string',
+		required: true,
+		default: '',
+		description: 'Key of the registrant to delete',
+		displayOptions: {
+			show: {
+				resource: ['registrant'],
+				operation: ['delete'],
+			},
+		},
+	},
+
+	// ----------------------------------
+	//         registrant: get
+	// ----------------------------------
+	{
+		displayName: 'Webinar Key Name or ID',
+		name: 'webinarKey',
+		type: 'options',
+		typeOptions: {
+			loadOptionsMethod: 'getWebinars',
+		},
+		required: true,
+		default: [],
+		description:
+			'Key of the webinar of the registrant to retrieve. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+		displayOptions: {
+			show: {
+				resource: ['registrant'],
+				operation: ['get'],
+			},
+		},
+	},
+	{
+		displayName: 'Registrant Key',
+		name: 'registrantKey',
+		type: 'string',
+		required: true,
+		default: '',
+		description: 'Key of the registrant to retrieve',
+		displayOptions: {
+			show: {
+				resource: ['registrant'],
+				operation: ['get'],
+			},
+		},
+	},
+];

packages/nodes-base/nodes/GoToWebinar/descriptions/SessionDescription.ts

@@ -0,0 +1,199 @@
+import type { INodeProperties } from 'n8n-workflow';
+
+export const sessionOperations: INodeProperties[] = [
+	{
+		displayName: 'Operation',
+		name: 'operation',
+		type: 'options',
+		noDataExpression: true,
+		default: 'get',
+		options: [
+			{
+				name: 'Get',
+				value: 'get',
+				action: 'Get a session',
+			},
+			{
+				name: 'Get Many',
+				value: 'getAll',
+				action: 'Get many sessions',
+			},
+			{
+				name: 'Get Details',
+				value: 'getDetails',
+				action: 'Get details on a session',
+			},
+		],
+		displayOptions: {
+			show: {
+				resource: ['session'],
+			},
+		},
+	},
+];
+
+export const sessionFields: INodeProperties[] = [
+	// ----------------------------------
+	//         session: getAll
+	// ----------------------------------
+	{
+		displayName: 'Return All',
+		name: 'returnAll',
+		type: 'boolean',
+		default: false,
+		description: 'Whether to return all results or only up to a given limit',
+		displayOptions: {
+			show: {
+				resource: ['session'],
+				operation: ['getAll'],
+			},
+		},
+	},
+	{
+		displayName: 'Limit',
+		name: 'limit',
+		type: 'number',
+		default: 10,
+		description: 'Max number of results to return',
+		typeOptions: {
+			minValue: 1,
+			maxValue: 100,
+		},
+		displayOptions: {
+			show: {
+				resource: ['session'],
+				operation: ['getAll'],
+				returnAll: [false],
+			},
+		},
+	},
+	{
+		displayName: 'Additional Fields',
+		name: 'additionalFields',
+		type: 'collection',
+		placeholder: 'Add Field',
+		displayOptions: {
+			show: {
+				resource: ['session'],
+				operation: ['getAll'],
+			},
+		},
+		default: {},
+		options: [
+			{
+				displayName: 'Time Range',
+				name: 'times',
+				type: 'fixedCollection',
+				placeholder: 'Add Time Range',
+				required: true,
+				default: {},
+				options: [
+					{
+						displayName: 'Times Properties',
+						name: 'timesProperties',
+						values: [
+							{
+								displayName: 'Start Time',
+								name: 'fromTime',
+								type: 'dateTime',
+								description: 'Start of the datetime range for the session',
+								default: '',
+							},
+							{
+								displayName: 'End Time',
+								name: 'toTime',
+								type: 'dateTime',
+								description: 'End of the datetime range for the session',
+								default: '',
+							},
+						],
+					},
+				],
+			},
+			{
+				displayName: 'Webinar Key Name or ID',
+				name: 'webinarKey',
+				type: 'options',
+				typeOptions: {
+					loadOptionsMethod: 'getWebinars',
+				},
+				default: {},
+				description:
+					'Webinar by which to filter the sessions to retrieve. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+			},
+		],
+	},
+
+	// ----------------------------------
+	//      session: shared fields
+	// ----------------------------------
+	{
+		displayName: 'Webinar Key Name or ID',
+		name: 'webinarKey',
+		type: 'options',
+		typeOptions: {
+			loadOptionsMethod: 'getWebinars',
+		},
+		required: true,
+		default: [],
+		description:
+			'Key of the webinar to which the session belongs. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+		displayOptions: {
+			show: {
+				resource: ['session'],
+				operation: ['get', 'getDetails'],
+			},
+		},
+	},
+	{
+		displayName: 'Session Key',
+		name: 'sessionKey',
+		type: 'string',
+		required: true,
+		default: '',
+		displayOptions: {
+			show: {
+				resource: ['session'],
+				operation: ['get', 'getDetails'],
+			},
+		},
+	},
+
+	// ----------------------------------
+	//        session: getDetails
+	// ----------------------------------
+	{
+		displayName: 'Details',
+		name: 'details',
+		type: 'options',
+		default: 'performance',
+		options: [
+			{
+				name: 'Performance',
+				value: 'performance',
+				description: 'Performance details for a webinar session',
+			},
+			{
+				name: 'Polls',
+				value: 'polls',
+				description: 'Questions and answers for polls from a webinar session',
+			},
+			{
+				name: 'Questions',
+				value: 'questions',
+				description: 'Questions and answers for a past webinar session',
+			},
+			{
+				name: 'Surveys',
+				value: 'surveys',
+				description: 'Surveys for a past webinar session',
+			},
+		],
+		displayOptions: {
+			show: {
+				resource: ['session'],
+				operation: ['getDetails'],
+			},
+		},
+	},
+];

packages/nodes-base/nodes/GoToWebinar/descriptions/WebinarDescription.ts

@@ -0,0 +1,492 @@
+import type { INodeProperties } from 'n8n-workflow';
+
+export const webinarOperations: INodeProperties[] = [
+	{
+		displayName: 'Operation',
+		name: 'operation',
+		type: 'options',
+		noDataExpression: true,
+		default: 'get',
+		options: [
+			{
+				name: 'Create',
+				value: 'create',
+				action: 'Create a webinar',
+			},
+			// {
+			// 	name: 'Delete',
+			// 	value: 'delete',
+			// },
+			{
+				name: 'Get',
+				value: 'get',
+				action: 'Get a webinar',
+			},
+			{
+				name: 'Get Many',
+				value: 'getAll',
+				action: 'Get many webinars',
+			},
+			{
+				name: 'Update',
+				value: 'update',
+				action: 'Update a webinar',
+			},
+		],
+		displayOptions: {
+			show: {
+				resource: ['webinar'],
+			},
+		},
+	},
+];
+
+export const webinarFields: INodeProperties[] = [
+	// ----------------------------------
+	//         webinar: create
+	// ----------------------------------
+	{
+		displayName: 'Subject',
+		name: 'subject',
+		type: 'string',
+		required: true,
+		default: '',
+		displayOptions: {
+			show: {
+				resource: ['webinar'],
+				operation: ['create'],
+			},
+		},
+	},
+	{
+		displayName: 'Time Range',
+		name: 'times',
+		type: 'fixedCollection',
+		required: true,
+		placeholder: 'Add Time Range',
+		typeOptions: {
+			multipleValues: true,
+		},
+		default: {},
+		displayOptions: {
+			show: {
+				resource: ['webinar'],
+				operation: ['create'],
+			},
+		},
+		options: [
+			{
+				displayName: 'Times Properties',
+				name: 'timesProperties',
+				values: [
+					{
+						displayName: 'Start Time',
+						name: 'startTime',
+						type: 'dateTime',
+						required: true,
+						default: '',
+					},
+					{
+						displayName: 'End Time',
+						name: 'endTime',
+						type: 'dateTime',
+						required: true,
+						default: '',
+					},
+				],
+			},
+		],
+	},
+	{
+		displayName: 'Additional Fields',
+		name: 'additionalFields',
+		type: 'collection',
+		placeholder: 'Add Field',
+		displayOptions: {
+			show: {
+				resource: ['webinar'],
+				operation: ['create'],
+			},
+		},
+		default: {},
+		options: [
+			{
+				displayName: 'Description',
+				name: 'description',
+				type: 'string',
+				default: '',
+			},
+			{
+				displayName: 'Experience Type',
+				name: 'experienceType',
+				type: 'options',
+				default: 'CLASSIC',
+				options: [
+					{
+						name: 'Classic',
+						value: 'CLASSIC',
+					},
+					{
+						name: 'Broadcast',
+						value: 'BROADCAST',
+					},
+					{
+						name: 'Simulive',
+						value: 'SIMULIVE',
+					},
+				],
+			},
+			{
+				displayName: 'Is On-Demand',
+				name: 'isOnDemand',
+				type: 'boolean',
+				default: false,
+			},
+			{
+				displayName: 'Is Password Protected',
+				name: 'isPasswordProtected',
+
+				type: 'boolean',
+				default: false,
+			},
+			{
+				displayName: 'Timezone Name or ID',
+				name: 'timezone',
+				type: 'options',
+				description:
+					'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>',
+				default: '',
+				placeholder: '2020-12-11T09:00:00Z',
+				typeOptions: {
+					alwaysOpenEditWindow: true,
+					loadOptionsMethod: 'getTimezones',
+				},
+			},
+			{
+				displayName: 'Webinar Type',
+				name: 'type',
+				type: 'options',
+				default: 'single_session',
+				options: [
+					{
+						name: 'Single Session',
+						value: 'single_session',
+						description: 'Webinar with one single meeting',
+					},
+					{
+						name: 'Series',
+						value: 'series',
+						description:
+							'Webinar with multiple meetings times where attendees choose only one to attend',
+					},
+					{
+						name: 'Sequence',
+						value: 'sequence',
+						description:
+							'Webinar with multiple meeting times where attendees are expected to be the same for all sessions',
+					},
+				],
+			},
+		],
+	},
+
+	// ----------------------------------
+	//         webinar: delete
+	// ----------------------------------
+	{
+		displayName: 'Webinar Key',
+		name: 'webinarKey',
+		type: 'string',
+		required: true,
+		default: '',
+		description: 'Key of the webinar to delete',
+		displayOptions: {
+			show: {
+				resource: ['webinar'],
+				operation: ['delete'],
+			},
+		},
+	},
+	{
+		displayName: 'Additional Fields',
+		name: 'additionalFields',
+		type: 'collection',
+		placeholder: 'Add Field',
+		displayOptions: {
+			show: {
+				resource: ['webinar'],
+				operation: ['delete'],
+			},
+		},
+		default: {},
+		options: [
+			{
+				displayName: 'Send Cancellation E-Mails',
+				name: 'sendCancellationEmails',
+				type: 'boolean',
+				default: false,
+			},
+		],
+	},
+
+	// ----------------------------------
+	//         webinar: get
+	// ----------------------------------
+	{
+		displayName: 'Webinar Key',
+		name: 'webinarKey',
+		type: 'string',
+		required: true,
+		default: '',
+		description: 'Key of the webinar to retrieve',
+		displayOptions: {
+			show: {
+				resource: ['webinar'],
+				operation: ['get'],
+			},
+		},
+	},
+
+	// ----------------------------------
+	//         webinar: getAll
+	// ----------------------------------
+	{
+		displayName: 'Return All',
+		name: 'returnAll',
+		type: 'boolean',
+		default: false,
+		description: 'Whether to return all results or only up to a given limit',
+		displayOptions: {
+			show: {
+				resource: ['webinar'],
+				operation: ['getAll'],
+			},
+		},
+	},
+	{
+		displayName: 'Limit',
+		name: 'limit',
+		type: 'number',
+		default: 10,
+		description: 'Max number of results to return',
+		typeOptions: {
+			minValue: 1,
+			maxValue: 100,
+		},
+		displayOptions: {
+			show: {
+				resource: ['webinar'],
+				operation: ['getAll'],
+				returnAll: [false],
+			},
+		},
+	},
+	{
+		displayName: 'Additional Fields',
+		name: 'additionalFields',
+		type: 'collection',
+		placeholder: 'Add Field',
+		displayOptions: {
+			show: {
+				resource: ['webinar'],
+				operation: ['getAll'],
+			},
+		},
+		default: {},
+		options: [
+			{
+				displayName: 'Time Range',
+				name: 'times',
+				type: 'fixedCollection',
+				placeholder: 'Add Time Range',
+				required: true,
+				default: {},
+				options: [
+					{
+						displayName: 'Times Properties',
+						name: 'timesProperties',
+						values: [
+							{
+								displayName: 'Start Time',
+								name: 'fromTime',
+								type: 'dateTime',
+								description: 'Start of the datetime range for the webinar',
+								default: '',
+							},
+							{
+								displayName: 'End Time',
+								name: 'toTime',
+								type: 'dateTime',
+								description: 'End of the datetime range for the webinar',
+								default: '',
+							},
+						],
+					},
+				],
+			},
+		],
+	},
+
+	// ----------------------------------
+	//         webinar: update
+	// ----------------------------------
+	{
+		displayName: 'Webinar Key',
+		name: 'webinarKey',
+		type: 'string',
+		required: true,
+		default: '',
+		description: 'Key of the webinar to update',
+		displayOptions: {
+			show: {
+				resource: ['webinar'],
+				operation: ['update'],
+			},
+		},
+	},
+	{
+		displayName: 'Notify Participants',
+		name: 'notifyParticipants',
+		type: 'boolean',
+		required: true,
+		default: false,
+		displayOptions: {
+			show: {
+				resource: ['webinar'],
+				operation: ['update'],
+			},
+		},
+	},
+	{
+		displayName: 'Update Fields',
+		name: 'updateFields',
+		type: 'collection',
+		placeholder: 'Add Field',
+		displayOptions: {
+			show: {
+				resource: ['webinar'],
+				operation: ['update'],
+			},
+		},
+		default: {},
+		options: [
+			{
+				displayName: 'Description',
+				name: 'description',
+				type: 'string',
+				default: '',
+			},
+			{
+				displayName: 'Experience Type',
+				name: 'experienceType',
+				type: 'options',
+				default: 'CLASSIC',
+				options: [
+					{
+						name: 'Classic',
+						value: 'CLASSIC',
+					},
+					{
+						name: 'Broadcast',
+						value: 'BROADCAST',
+					},
+					{
+						name: 'Simulive',
+						value: 'SIMULIVE',
+					},
+				],
+			},
+			{
+				displayName: 'Is On-Demand',
+				name: 'isOnDemand',
+				type: 'boolean',
+				default: false,
+				description: 'Whether the webinar may be watched anytime',
+			},
+			{
+				displayName: 'Is Password Protected',
+				name: 'isPasswordProtected',
+
+				type: 'boolean',
+				default: false,
+				description: 'Whether the webinar requires a password for attendees to join',
+			},
+			{
+				displayName: 'Times',
+				name: 'times',
+				type: 'fixedCollection',
+				default: {},
+				typeOptions: {
+					multipleValues: true,
+				},
+				options: [
+					{
+						displayName: 'Times Properties',
+						name: 'timesProperties',
+						values: [
+							{
+								displayName: 'Start Time',
+								name: 'startTime',
+								type: 'dateTime',
+								required: true,
+								default: '',
+							},
+							{
+								displayName: 'End Time',
+								name: 'endTime',
+								type: 'dateTime',
+								required: true,
+								default: '',
+							},
+						],
+					},
+				],
+			},
+			{
+				displayName: 'Subject',
+				name: 'subject',
+				type: 'string',
+				default: '',
+				description: 'Name or topic of the webinar',
+			},
+			{
+				displayName: 'Timezone Name or ID',
+				name: 'timezone',
+				type: 'options',
+				default: '',
+				placeholder: '2020-12-11T09:00:00Z',
+				description:
+					'Timezone where the webinar is to take place. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+				typeOptions: {
+					alwaysOpenEditWindow: true,
+					loadOptionsMethod: 'getTimezones',
+				},
+			},
+			{
+				displayName: 'Webinar Type',
+				name: 'type',
+				type: 'options',
+				default: 'single_session',
+				options: [
+					{
+						name: 'Single Session',
+						value: 'single_session',
+						description: 'Webinar with one single meeting',
+					},
+					{
+						name: 'Series',
+						value: 'series',
+						description:
+							'Webinar with multiple meetings times where attendees choose only one to attend',
+					},
+					{
+						name: 'Sequence',
+						value: 'sequence',
+						description:
+							'Webinar with multiple meeting times where attendees are expected to be the same for all sessions',
+					},
+				],
+			},
+		],
+	},
+];

packages/nodes-base/nodes/GoToWebinar/descriptions/index.ts

@@ -0,0 +1,6 @@
+export * from './AttendeeDescription';
+export * from './CoorganizerDescription';
+export * from './PanelistDescription';
+export * from './RegistrantDescription';
+export * from './SessionDescription';
+export * from './WebinarDescription';