n8n/packages/nodes-base/nodes/Mailchimp/Mailchimp.node.ts

import {
	IExecuteFunctions,
} from 'n8n-core';

import {
	IDataObject,
	ILoadOptionsFunctions,
	INodeExecutionData,
	INodePropertyOptions,
	INodeType,
	INodeTypeDescription,
} from 'n8n-workflow';

import {
	campaignFieldsMetadata,
	mailchimpApiRequest,
	mailchimpApiRequestAllItems,
	validateJSON,
} from './GenericFunctions';

import * as moment from 'moment';

enum Status {
	subscribe = 'subscribe',
	unsubscribed = 'unsubscribe',
	cleaned = 'cleaned',
	pending = 'pending',
	transactional = 'transactional',
}

interface ILocation {
	latitude?: number;
	longitude?: number;
}

interface ICreateMemberBody {
	listId: string;
	email_address: string;
	email_type?: string;
	status?: Status;
	language?: string;
	vip?: boolean;
	location?: ILocation;
	ip_signup?: string;
	timestamp_signup?: string;
	ip_opt?: string;
	timestamp_opt?: string;
	tags?: string[];
	merge_fields?: IDataObject;
	interests?: IDataObject;
}

export class Mailchimp implements INodeType {

	description: INodeTypeDescription = {
		displayName: 'Mailchimp',
		name: 'mailchimp',
		icon: 'file:mailchimp.svg',
		group: ['output'],
		version: 1,
		subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
		description: 'Consume Mailchimp API',
		defaults: {
			name: 'Mailchimp',
		},
		inputs: ['main'],
		outputs: ['main'],
		credentials: [
			{
				name: 'mailchimpApi',
				required: true,
				displayOptions: {
					show: {
						authentication: [
							'apiKey',
						],
					},
				},
			},
			{
				name: 'mailchimpOAuth2Api',
				required: true,
				displayOptions: {
					show: {
						authentication: [
							'oAuth2',
						],
					},
				},
			},
		],
		properties: [
			{
				displayName: 'Authentication',
				name: 'authentication',
				type: 'options',
				options: [
					{
						name: 'API Key',
						value: 'apiKey',
					},
					{
						name: 'OAuth2',
						value: 'oAuth2',
					},
				],
				default: 'apiKey',
				description: 'Method of authentication.',
			},
			{
				displayName: 'Resource',
				name: 'resource',
				type: 'options',
				options: [
					{
						name: 'Campaign',
						value: 'campaign',
					},
					{
						name: 'List Group',
						value: 'listGroup',
					},
					{
						name: 'Member',
						value: 'member',
					},
					{
						name: 'Member Tag',
						value: 'memberTag',
					},
				],
				default: 'member',
				required: true,
				description: 'Resource to consume.',
			},
			{
				displayName: 'Operation',
				name: 'operation',
				type: 'options',
				required: true,
				displayOptions: {
					show: {
						resource: [
							'member',
						],
					},
				},
				options: [
					{
						name: 'Create',
						value: 'create',
						description: 'Create a new member on list',
					},
					{
						name: 'Delete',
						value: 'delete',
						description: 'Delete a member on list',
					},
					{
						name: 'Get',
						value: 'get',
						description: 'Get a member on list',
					},
					{
						name: 'Get All',
						value: 'getAll',
						description: 'Get all members on list',
					},
					{
						name: 'Update',
						value: 'update',
						description: 'Update a new member on list',
					},
				],
				default: 'create',
				description: 'The operation to perform.',
			},
			{
				displayName: 'Operation',
				name: 'operation',
				type: 'options',
				required: true,
				displayOptions: {
					show: {
						resource: [
							'memberTag',
						],
					},
				},
				options: [
					{
						name: 'Create',
						value: 'create',
						description: 'Add tags from a list member',
					},
					{
						name: 'Delete',
						value: 'delete',
						description: 'Remove tags from a list member',
					},
				],
				default: 'create',
				description: 'The operation to perform.',
			},
			{
				displayName: 'Operation',
				name: 'operation',
				type: 'options',
				required: true,
				displayOptions: {
					show: {
						resource: [
							'listGroup',
						],
					},
				},
				options: [
					{
						name: 'Get All',
						value: 'getAll',
						description: 'Get all groups',
					},
				],
				default: 'getAll',
				description: 'The operation to perform.',
			},
			{
				displayName: 'Operation',
				name: 'operation',
				type:'options',
				required: true,
				displayOptions : {
					show: {
						resource: [
							'campaign',
						],
					},

				},
				options: [
					{
						name: 'Delete',
						value: 'delete',
						description: 'Delete a campaign',
					},
					{
						name: 'Get',
						value: 'get',
						description: 'Get a campaign',
					},
					{
						name: 'Get All',
						value: 'getAll',
						description: 'Get all the campaigns',
					},
					{
						name: 'Replicate',
						value: 'replicate',
						description: 'Replicate a campaign',
					},
					{
						name: 'Resend',
						value: 'resend',
						description: 'Creates a Resend to Non-Openers version of this campaign',
					},
					{
						name: 'Send',
						value: 'send',
						description: 'Send a campaign',
					},
				],
				default: 'getAll',
				description: 'The operation to perform.',
			},
/* -------------------------------------------------------------------------- */
/*                                 member:create                              */
/* -------------------------------------------------------------------------- */
			{
				displayName: 'List',
				name: 'list',
				type: 'options',
				typeOptions: {
					loadOptionsMethod: 'getLists',
				},
				displayOptions: {
					show: {
						resource: [
							'member',
						],
						operation: [
							'create',
						],
					},
				},
				default: '',
				options: [],
				required: true,
				description: 'List of lists',
			},
			{
				displayName: 'Email',
				name: 'email',
				type: 'string',
				required: true,
				displayOptions: {
					show: {
						resource: [
							'member',
						],
						operation: [
							'create',
						],
					},
				},
				default: '',
				description: 'Email address for a subscriber.',
			},
			{
				displayName: 'Status',
				name: 'status',
				type: 'options',
				required: true,
				displayOptions: {
					show: {
						resource: [
							'member',
						],
						operation: [
							'create',
						],
					},
				},
				options: [
					{
						name: 'Subscribed',
						value: 'subscribed',
					},
					{
						name: 'Unsubscribed',
						value: 'unsubscribed',
					},
					{
						name: 'Cleaned',
						value: 'cleaned',
					},
					{
						name: 'Pending',
						value: 'pending',
					},
					{
						name: 'Transactional',
						value: 'transactional',
					},
				],
				default: '',
				description: `Subscriber's current status.`,
			},
			{
				displayName: 'JSON Parameters',
				name: 'jsonParameters',
				type: 'boolean',
				default: false,
				displayOptions: {
					show: {
						resource:[
							'member',
						],
						operation: [
							'create',
						],
					},
				},
			},
			{
				displayName: 'Options',
				name: 'options',
				type: 'collection',
				placeholder: 'Add Option',
				default: {},
				displayOptions: {
					show: {
						resource:[
							'member',
						],
						operation: [
							'create',
						],
					},
				},
				options: [
					{
						displayName: 'Email Type',
						name: 'emailType',
						type: 'options',
						options: [
							{
								name: 'HTML',
								value: 'html',
							},
							{
								name: 'Text',
								value: 'text',
							},
						],
						default: '',
						description: 'Type of email this member asked to get',
					},
					{
						displayName: 'Language',
						name: 'language',
						type: 'string',
						default: '',
						description: `If set/detected, the subscriber's language.`,
					},
					{
						displayName: 'Opt-in IP',
						name: 'ipOptIn',
						type: 'string',
						default: '',
						description: 'The IP address the subscriber used to confirm their opt-in status.',
					},
					{
						displayName: 'Signup IP',
						name: 'ipSignup',
						type: 'string',
						default: '',
						description: 'IP address the subscriber signed up from.',
					},
					{
						displayName: 'Signup Timestamp',
						name: 'timestampSignup',
						type: 'dateTime',
						default: '',
						description: 'The date and time the subscriber signed up for the list in ISO 8601 format.',
					},
					{
						displayName: 'Tags',
						name: 'tags',
						type: 'string',
						default: '',
						description: `The tags that are associated with a member separeted by ,.`,
					},
					{
						displayName: 'Vip',
						name: 'vip',
						type: 'boolean',
						default: false,
						description: `Vip status for subscribers`,
					},
					{
						displayName: 'Opt-in Timestamp',
						name: 'timestampOpt',
						type: 'dateTime',
						default: '',
						description: `The date and time the subscribe confirmed their opt-in status in ISO 8601 format.`,
					},
				],
			},
			{
				displayName: 'Location',
				name: 'locationFieldsUi',
				type: 'fixedCollection',
				placeholder: 'Add Location',
				default: {},
				description: `Subscriber location information.n`,
				displayOptions: {
					show: {
						resource:[
							'member',
						],
						operation: [
							'create',
						],
						jsonParameters: [
							false,
						],
					},
				},
				options: [
					{
						name: 'locationFieldsValues',
						displayName: 'Location',
						values: [
							{
								displayName: 'Latitude',
								name: 'latitude',
								type: 'string',
								required: true,
								description: 'The location latitude.',
								default: '',
							},
							{
								displayName: 'Longitude',
								name: 'longitude',
								type: 'string',
								required: true,
								description: 'The location longitude.',
								default: '',
							},
						],
					},
				],
			},
			{
				displayName: 'Merge Fields',
				name: 'mergeFieldsUi',
				placeholder: 'Add Merge Fields',
				type: 'fixedCollection',
				default: {},
				typeOptions: {
					multipleValues: true,
				},
				displayOptions: {
					show: {
						resource:[
							'member',
						],
						operation: [
							'create',
						],
						jsonParameters: [
							false,
						],
					},
				},
				description: 'An individual merge var and value for a member.',
				options: [
					{
						name: 'mergeFieldsValues',
						displayName: 'Field',
						typeOptions: {
							multipleValueButtonText: 'Add Field',
						},
						values: [
							{
								displayName: 'Field Name',
								name: 'name',
								type: 'options',
								typeOptions: {
									loadOptionsMethod: 'getMergeFields',
									loadOptionsDependsOn: [
										'list',
									],
								},
								required: true,
								description: 'Merge Field name',
								default: '',
							},
							{
								displayName: 'Field Value',
								name: 'value',
								required: true,
								type: 'string',
								default: '',
								description: 'Merge field value.',
							},
						],
					},
				],
			},
			{
				displayName: 'Merge Fields',
				name: 'mergeFieldsJson',
				type: 'json',
				typeOptions: {
					alwaysOpenEditWindow: true,
				},
				default: '',
				displayOptions: {
					show: {
						resource:[
							'member',
						],
						operation: [
							'create',
						],
						jsonParameters: [
							true,
						],
					},
				},
			},
			{
				displayName: 'Location',
				name: 'locationJson',
				type: 'json',
				typeOptions: {
					alwaysOpenEditWindow: true,
				},
				default: '',
				displayOptions: {
					show: {
						resource:[
							'member',
						],
						operation: [
							'create',
						],
						jsonParameters: [
							true,
						],
					},
				},
			},
			{
				displayName: 'Interest Groups',
				name: 'groupsUi',
				placeholder: 'Add Interest Group',
				type: 'fixedCollection',
				default: {},
				typeOptions: {
					multipleValues: true,
				},
				displayOptions: {
					show: {
						resource:[
							'member',
						],
						operation: [
							'create',
						],
						jsonParameters: [
							false,
						],
					},
				},
				options: [
					{
						name: 'groupsValues',
						displayName: 'Group',
						typeOptions: {
							multipleValueButtonText: 'Add Interest Group',
						},
						values: [
							{
								displayName: 'Category ID',
								name: 'categoryId',
								type: 'options',
								typeOptions: {
									loadOptionsMethod: 'getGroupCategories',
									loadOptionsDependsOn: [
										'list',
									],
								},
								default: '',
							},
							{
								displayName: 'Category Field ID',
								name: 'categoryFieldId',
								type: 'string',
								default: '',
							},
							{
								displayName: 'Value',
								name: 'value',
								type: 'boolean',
								default: false,
							},
						],
					},
				],
			},
			{
				displayName: 'Interest Groups',
				name: 'groupJson',
				type: 'json',
				typeOptions: {
					alwaysOpenEditWindow: true,
				},
				default: '',
				displayOptions: {
					show: {
						resource:[
							'member',
						],
						operation: [
							'create',
						],
						jsonParameters: [
							true,
						],
					},
				},
			},
/* -------------------------------------------------------------------------- */
/*                                 member:delete                              */
/* -------------------------------------------------------------------------- */
			{
				displayName: 'List',
				name: 'list',
				type: 'options',
				typeOptions: {
					loadOptionsMethod: 'getLists',
				},
				displayOptions: {
					show: {
						resource: [
							'member',
						],
						operation: [
							'delete',
						],
					},
				},
				default: '',
				options: [],
				required: true,
				description: 'List of lists',
			},
			{
				displayName: 'Email',
				name: 'email',
				type: 'string',
				displayOptions: {
					show: {
						resource: [
							'member',
						],
						operation: [
							'delete',
						],
					},
				},
				default: '',
				required: true,
				description: `Member's email`,
			},
/* -------------------------------------------------------------------------- */
/*                                 member:get                                 */
/* -------------------------------------------------------------------------- */
			{
				displayName: 'List',
				name: 'list',
				type: 'options',
				typeOptions: {
					loadOptionsMethod: 'getLists',
				},
				displayOptions: {
					show: {
						resource: [
							'member',
						],
						operation: [
							'get',
						],
					},
				},
				default: '',
				options: [],
				required: true,
				description: 'List of lists',
			},
			{
				displayName: 'Email',
				name: 'email',
				type: 'string',
				displayOptions: {
					show: {
						resource: [
							'member',
						],
						operation: [
							'get',
						],
					},
				},
				default: '',
				required: true,
				description: `Member's email`,
			},
			{
				displayName: 'Options',
				name: 'options',
				type: 'collection',
				placeholder: 'Add Option',
				default: {},
				displayOptions: {
					show: {
						resource:[
							'member',
						],
						operation: [
							'get',
						],
					},
				},
				options: [
					{
						displayName: 'Fields',
						name: 'fields',
						type: 'string',
						default: '',
						description: 'A comma-separated list of fields to return.',
					},
					{
						displayName: 'Exclude Fields',
						name: 'excludeFields',
						type: 'string',
						default: '',
						description: 'A comma-separated list of fields to exclude.',
					},
				],
			},
/* -------------------------------------------------------------------------- */
/*                                 member:getAll                              */
/* -------------------------------------------------------------------------- */
			{
				displayName: 'List',
				name: 'list',
				type: 'options',
				typeOptions: {
					loadOptionsMethod: 'getLists',
				},
				displayOptions: {
					show: {
						resource: [
							'member',
						],
						operation: [
							'getAll',
						],
					},
				},
				default: '',
				options: [],
				required: true,
				description: 'List of lists',
			},
			{
				displayName: 'Return All',
				name: 'returnAll',
				type: 'boolean',
				displayOptions: {
					show: {
						resource: [
							'member',
						],
						operation: [
							'getAll',
						],
					},
				},
				default: false,
				description: 'If all results should be returned or only up to a given limit.',
			},
			{
				displayName: 'Limit',
				name: 'limit',
				type: 'number',
				displayOptions: {
					show: {
						resource: [
							'member',
						],
						operation: [
							'getAll',
						],
						returnAll: [
							false,
						],
					},
				},
				typeOptions: {
					minValue: 1,
					maxValue: 1000,
				},
				default: 500,
				description: 'How many results to return.',
			},
			{
				displayName: 'Options',
				name: 'options',
				type: 'collection',
				placeholder: 'Add Option',
				default: {},
				displayOptions: {
					show: {
						resource:[
							'member',
						],
						operation: [
							'getAll',
						],
					},
				},
				options: [
					{
						displayName: 'Before Last Changed',
						name: 'beforeLastChanged',
						type: 'dateTime',
						default: '',
						description: 'Restrict results to subscribers whose information changed before the set timeframe.',
					},
					{
						displayName: 'Before Timestamp Opt',
						name: 'beforeTimestampOpt',
						type: 'dateTime',
						default: '',
						description: 'Restrict results to subscribers who opted-in before the set timeframe',
					},
					// {
					// 	displayName: 'Fields',
					// 	name: 'fields',
					// 	type: 'string',
					// 	default: '',
					// 	description: 'A comma-separated list of fields to return.',
					// },
					// {
					// 	displayName: 'Exclude Fields',
					// 	name: 'excludeFields',
					// 	type: 'string',
					// 	default: '',
					// 	description: 'A comma-separated list of fields to exclude.',
					// },
					{
						displayName: 'Email Type',
						name: 'emailType',
						type: 'options',
						options: [
							{
								name: 'HTML',
								value: 'html',
							},
							{
								name: 'Text',
								value: 'text',
							},
						],
						default: '',
						description: 'Type of email this member asked to get',
					},
					{
						displayName: 'Status',
						name: 'status',
						type: 'options',
						options: [
							{
								name: 'Subscribed',
								value: 'subscribed',
							},
							{
								name: 'Unsubscribed',
								value: 'unsubscribed',
							},
							{
								name: 'Cleaned',
								value: 'cleaned',
							},
							{
								name: 'Pending',
								value: 'pending',
							},
							{
								name: 'Transactional',
								value: 'transactional',
							},
						],
						default: '',
						description: `Subscriber's current status.`,
					},
					{
						displayName: 'Since Last Changed',
						name: 'sinceLastChanged',
						type: 'dateTime',
						default: '',
						description: 'Restrict results to subscribers whose information changed after the set timeframe.',
					},
				],
			},
/* -------------------------------------------------------------------------- */
/*                                 member:update                              */
/* -------------------------------------------------------------------------- */
			{
				displayName: 'List',
				name: 'list',
				type: 'options',
				typeOptions: {
					loadOptionsMethod: 'getLists',
				},
				displayOptions: {
					show: {
						resource: [
							'member',
						],
						operation: [
							'update',
						],
					},
				},
				default: '',
				options: [],
				required: true,
				description: 'List of lists',
			},
			{
				displayName: 'Email',
				name: 'email',
				type: 'string',
				required: true,
				displayOptions: {
					show: {
						resource: [
							'member',
						],
						operation: [
							'update',
						],
					},
				},
				default: '',
				description: 'Email address of the subscriber.',
			},
			{
				displayName: 'JSON Parameters',
				name: 'jsonParameters',
				type: 'boolean',
				default: false,
				displayOptions: {
					show: {
						resource:[
							'member',
						],
						operation: [
							'update',
						],
					},
				},
			},
			{
				displayName: 'Update Fields',
				name: 'updateFields',
				type: 'collection',
				placeholder: 'Add Field',
				default: {},
				displayOptions: {
					show: {
						resource:[
							'member',
						],
						operation: [
							'update',
						],
					},
				},
				options: [
					{
						displayName: 'Email Type',
						name: 'emailType',
						type: 'options',
						options: [
							{
								name: 'HTML',
								value: 'html',
							},
							{
								name: 'Text',
								value: 'text',
							},
						],
						default: '',
						description: 'Type of email this member asked to get',
					},
					{
						displayName: 'Interest Groups',
						name: 'groupsUi',
						placeholder: 'Add Interest Group',
						type: 'fixedCollection',
						default: {},
						typeOptions: {
							multipleValues: true,
						},
						displayOptions: {
							show: {
								'/resource':[
									'member',
								],
								'/operation':[
									'update',
								],
								'/jsonParameters': [
									false,
								],
							},
						},
						options: [
							{
								name: 'groupsValues',
								displayName: 'Group',
								typeOptions: {
									multipleValueButtonText: 'Add Interest Group',
								},
								values: [
									{
										displayName: 'Category ID',
										name: 'categoryId',
										type: 'options',
										typeOptions: {
											loadOptionsMethod: 'getGroupCategories',
											loadOptionsDependsOn: [
												'list',
											],
										},
										default: '',
									},
									{
										displayName: 'Category Field ID',
										name: 'categoryFieldId',
										type: 'string',
										default: '',
									},
									{
										displayName: 'Value',
										name: 'value',
										type: 'boolean',
										default: false,
									},
								],
							},
						],
					},
					{
						displayName: 'Language',
						name: 'language',
						type: 'string',
						default: '',
						description: `If set/detected, the subscriber's language.`,
					},
					{
						displayName: 'Merge Fields',
						name: 'mergeFieldsUi',
						placeholder: 'Add Merge Fields',
						type: 'fixedCollection',
						default: {},
						typeOptions: {
							multipleValues: true,
						},
						displayOptions: {
							show: {
								'/resource':[
									'member',
								],
								'/operation':[
									'update',
								],
								'/jsonParameters': [
									false,
								],
							},
						},
						description: 'An individual merge var and value for a member.',
						options: [
							{
								name: 'mergeFieldsValues',
								displayName: 'Field',
								typeOptions: {
									multipleValueButtonText: 'Add Field',
								},
								values: [
									{
										displayName: 'Field Name',
										name: 'name',
										type: 'options',
										typeOptions: {
											loadOptionsMethod: 'getMergeFields',
											loadOptionsDependsOn: [
												'list',
											],
										},
										required: true,
										description: 'Merge Field name',
										default: '',
									},
									{
										displayName: 'Field Value',
										name: 'value',
										required: true,
										type: 'string',
										default: '',
										description: 'Merge field value.',
									},
								],
							},
						],
					},
					{
						displayName: 'Opt-in IP',
						name: 'ipOptIn',
						type: 'string',
						default: '',
						description: 'The IP address the subscriber used to confirm their opt-in status.',
					},
					{
						displayName: 'Signup IP',
						name: 'ipSignup',
						type: 'string',
						default: '',
						description: 'IP address the subscriber signed up from.',
					},
					{
						displayName: 'Signup Timestamp',
						name: 'timestampSignup',
						type: 'dateTime',
						default: '',
						description: 'The date and time the subscriber signed up for the list in ISO 8601 format.',
					},
					{
						displayName: 'Skip Merge Validation',
						name: 'skipMergeValidation',
						type: 'boolean',
						default: false,
						description: `If skip_merge_validation is true, member data will be accepted without merge field values,
						even if the merge field is usually required`,
					},
					{
						displayName: 'Status',
						name: 'status',
						type: 'options',
						required: true,
						options: [
							{
								name: 'Subscribed',
								value: 'subscribed',
							},
							{
								name: 'Unsubscribed',
								value: 'unsubscribed',
							},
							{
								name: 'Cleaned',
								value: 'cleaned',
							},
							{
								name: 'Pending',
								value: 'pending',
							},
							{
								name: 'Transactional',
								value: 'transactional',
							},
						],
						default: '',
						description: `Subscriber's current status.`,
					},
					{
						displayName: 'Vip',
						name: 'vip',
						type: 'boolean',
						default: false,
						description: `Vip status for subscribers`,
					},
					{
						displayName: 'Location',
						name: 'locationFieldsUi',
						type: 'fixedCollection',
						placeholder: 'Add Location',
						default: {},
						description: `Subscriber location information.n`,
						displayOptions: {
							show: {
								'/resource':[
									'member',
								],
								'/operation':[
									'update',
								],
								'/jsonParameters': [
									false,
								],
							},
						},
						options: [
							{
								name: 'locationFieldsValues',
								displayName: 'Location',
								values: [
									{
										displayName: 'Latitude',
										name: 'latitude',
										type: 'string',
										required: true,
										description: 'The location latitude.',
										default: '',
									},
									{
										displayName: 'Longitude',
										name: 'longitude',
										type: 'string',
										required: true,
										description: 'The location longitude.',
										default: '',
									},
								],
							},
						],
					},
					{
						displayName: 'Opt-in Timestamp',
						name: 'timestampOpt',
						type: 'dateTime',
						default: '',
						description: `The date and time the subscribe confirmed their opt-in status in ISO 8601 format.`,
					},
				],
			},
			{
				displayName: 'Merge Fields',
				name: 'mergeFieldsJson',
				type: 'json',
				typeOptions: {
					alwaysOpenEditWindow: true,
				},
				default: '',
				displayOptions: {
					show: {
						resource:[
							'member',
						],
						operation: [
							'update',
						],
						jsonParameters: [
							true,
						],
					},
				},
			},
			{
				displayName: 'Location',
				name: 'locationJson',
				type: 'json',
				typeOptions: {
					alwaysOpenEditWindow: true,
				},
				default: '',
				displayOptions: {
					show: {
						resource:[
							'member',
						],
						operation: [
							'update',
						],
						jsonParameters: [
							true,
						],
					},
				},
			},
			{
				displayName: 'Interest Groups',
				name: 'groupJson',
				type: 'json',
				typeOptions: {
					alwaysOpenEditWindow: true,
				},
				default: '',
				displayOptions: {
					show: {
						resource:[
							'member',
						],
						operation: [
							'update',
						],
						jsonParameters: [
							true,
						],
					},
				},
			},
/* -------------------------------------------------------------------------- */
/*                                 memberTag:create                           */
/* -------------------------------------------------------------------------- */
			{
				displayName: 'List',
				name: 'list',
				type: 'options',
				typeOptions: {
					loadOptionsMethod: 'getLists',
				},
				displayOptions: {
					show: {
						resource: [
							'memberTag',
						],
						operation: [
							'create',
							'delete',
						],
					},
				},
				default: '',
				options: [],
				required: true,
				description: 'List of lists',
			},
			{
				displayName: 'Email',
				name: 'email',
				type: 'string',
				required: true,
				displayOptions: {
					show: {
						resource: [
							'memberTag',
						],
						operation: [
							'create',
							'delete',
						],
					},
				},
				default: '',
				description: 'Email address of the subscriber.',
			},
			{
				displayName: 'Tags',
				name: 'tags',
				type: 'string',
				typeOptions: {
					multipleValues: true,
					multipleValueButtonText: 'Add Tag',
				},
				displayOptions: {
					show: {
						resource:[
							'memberTag',
						],
						operation: [
							'create',
							'delete',
						],
					},
				},
				default: [],
			},
			{
				displayName: 'Options',
				name: 'options',
				type: 'collection',
				placeholder: 'Add Option',
				default: {},
				displayOptions: {
					show: {
						resource:[
							'memberTag',
						],
						operation: [
							'create',
							'delete',
						],
					},
				},
				options: [
					{
						displayName: 'Is Syncing',
						name: 'isSyncing',
						type: 'boolean',
						default: false,
						description: 'When is_syncing is true, automations based on the tags in the request will not fire',
					},
				],
			},
/* -------------------------------------------------------------------------- */
/*                                 member:getAll                              */
/* -------------------------------------------------------------------------- */
			{
				displayName: 'List',
				name: 'list',
				type: 'options',
				typeOptions: {
					loadOptionsMethod: 'getLists',
				},
				displayOptions: {
					show: {
						resource: [
							'listGroup',
						],
						operation: [
							'getAll',
						],
					},
				},
				default: '',
				options: [],
				required: true,
				description: 'List of lists',
			},
			{
				displayName: 'Group Category',
				name: 'groupCategory',
				type: 'options',
				typeOptions: {
					loadOptionsMethod: 'getGroupCategories',
					loadOptionsDependsOn: [
						'list',
					],
				},
				displayOptions: {
					show: {
						resource: [
							'listGroup',
						],
						operation: [
							'getAll',
						],
					},
				},
				default: '',
				options: [],
				required: true,
			},
			{
				displayName: 'Return All',
				name: 'returnAll',
				type: 'boolean',
				displayOptions: {
					show: {
						resource: [
							'listGroup',
						],
						operation: [
							'getAll',
						],
					},
				},
				default: false,
				description: 'If all results should be returned or only up to a given limit.',
			},
			{
				displayName: 'Limit',
				name: 'limit',
				type: 'number',
				displayOptions: {
					show: {
						resource: [
							'listGroup',
						],
						operation: [
							'getAll',
						],
						returnAll: [
							false,
						],
					},
				},
				typeOptions: {
					minValue: 1,
					maxValue: 1000,
				},
				default: 500,
				description: 'How many results to return.',
			},
/* -------------------------------------------------------------------------- */
/*                                 campaign:getAll                            */
/* -------------------------------------------------------------------------- */
			{
				displayName: 'Return All',
				name: 'returnAll',
				type: 'boolean',
				displayOptions: {
					show: {
						resource: [
							'campaign',
						],
						operation: [
							'getAll',
						],
					},
				},
				default: false,
				description: 'If all results should be returned or only up to a given limit.',
			},
			{
				displayName: 'Limit',
				name: 'limit',
				type: 'number',
				displayOptions: {
					show: {
						resource: [
							'campaign',
						],
						operation: [
							'getAll',
						],
						returnAll: [
							false,
						],
					},
				},
				typeOptions: {
					minValue: 1,
					maxValue: 1000,
				},
				default: 10,
				description: 'How many results to return.',
			},
			{
				displayName: 'Options',
				name: 'options',
				type: 'collection',
				placeholder: 'Add Option',
				default: {},
				displayOptions: {
					show: {
						resource:[
							'campaign',
						],
						operation: [
							'getAll',
						],
					},
				},
				options: [
					{
						displayName: 'Before Create Time',
						name: 'beforeCreateTime',
						type: 'dateTime',
						default: '',
						description: 'Restrict the response to campaigns created before the set time.',
					},
					{
						displayName: 'Before Send Time',
						name: 'beforeSendTime',
						type: 'dateTime',
						default: '',
						description: 'Restrict the response to campaigns sent before the set time.',
					},
					{
						displayName: 'Exclude Fields',
						name: 'excludeFields',
						type: 'multiOptions',
						typeOptions: {
							loadOptionsMethod: 'getCampaignsFields',
						},
						default: [],
						description: 'A comma-separated list of fields to exclude.',
					},
					{
						displayName: 'Fields',
						name: 'fields',
						type: 'multiOptions',
						typeOptions: {
							loadOptionsMethod: 'getCampaignsFields',
						},
						default: [
							'campaigns.id',
							'campaigns.status',
							'campaigns.tracking',
							'campaigns.settings.from_name',
							'campaigns.settings.reply_to',
							'campaigns.settings.title',
						],
						description: 'A comma-separated list of fields to return.',
					},
					{
						displayName: 'List ID',
						name: 'listId',
						type: 'options',
						typeOptions: {
							loadOptionsMethod: 'getLists',
						},
						default: '',
						description: 'List of lists',
					},
					{
						displayName: 'Since Create Time',
						name: 'sinceCreateTime',
						type: 'dateTime',
						default: '',
						description: 'Restrict the response to campaigns created after the set time.',
					},
					{
						displayName: 'Since Send Time',
						name: 'sinceSendTime',
						type: 'dateTime',
						default: '',
						description: 'Restrict the response to campaigns sent after the set time.',
					},
					{
						displayName: 'Sort Direction',
						name: 'sortDirection',
						type: 'options',
						options: [
							{
								name: 'ASC',
								value: 'ASC',
							},
							{
								name: 'DESC',
								value: 'DESC',
							},
						],
						default: '',
						description: 'Determines the order direction for sorted results.',
					},
					{
						displayName: 'Sort Field',
						name: 'sortField',
						type: 'options',
						options: [
							{
								name: 'Create Time',
								value: 'create_time',
							},
							{
								name: 'Send Time',
								value: 'send_time',
							},
						],
						default: '',
						description: 'Returns files sorted by the specified field.',
					},
					{
						displayName: 'Status',
						name: 'status',
						type: 'options',
						options: [
							{
								name: 'Save',
								value: 'save',
							},
							{
								name: 'Sending',
								value: 'sending',
							},
							{
								name: 'Sent',
								value: 'sent',
							},
							{
								name: 'Schedule',
								value: 'schedule',
							},
						],
						default: '',
						description: 'The status of the campaign.',
					},
				],
			},
/* -------------------------------------------------------------------------- */
/*                                 campaign:send                              */
/* -------------------------------------------------------------------------- */
			{
				displayName: 'Campaign ID',
				name: 'campaignId',
				type: 'string',
				displayOptions: {
					show: {
						resource: [
							'campaign',
						],
						operation: [
							'send',
							'get',
							'delete',
							'replicate',
							'resend',
						],
					},
				},
				required: true,
				default: '',
				description: 'List of Campaigns',
				options:[],
			},
		],
	};


	methods = {
		loadOptions: {

			// Get all the available lists to display them to user so that he can
			// select them easily
			async getLists(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
				const returnData: INodePropertyOptions[] = [];
				const lists = await mailchimpApiRequestAllItems.call(this, '/lists', 'GET', 'lists');
				for (const list of lists) {
					const listName = list.name;
					const listId = list.id;
					returnData.push({
						name: listName,
						value: listId,
					});
				}
				return returnData;
			},

			// Get all the available merge fields to display them to user so that he can
			// select them easily
			async getMergeFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
				const returnData: INodePropertyOptions[] = [];
				const listId = this.getCurrentNodeParameter('list');
				const { merge_fields } = await mailchimpApiRequest.call(this, `/lists/${listId}/merge-fields`, 'GET');
				for (const mergeField of merge_fields) {
					const mergeFieldName = mergeField.name;
					const mergeFieldId = mergeField.tag;
					returnData.push({
						name: mergeFieldName,
						value: mergeFieldId,
					});
				}
				return returnData;
			},

			// Get all the interest fields to display them to user so that he can
			// select them easily
			async getGroupCategories(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
				const returnData: INodePropertyOptions[] = [];
				const listId = this.getCurrentNodeParameter('list');
				const { categories } = await mailchimpApiRequest.call(this, `/lists/${listId}/interest-categories`, 'GET');
				for (const category of categories) {
					const categoryName = category.title;
					const categoryId = category.id;
					returnData.push({
						name: categoryName,
						value: categoryId,
					});
				}
				return returnData;
			},

			// Get all the available campaigns to display them to users so that they can select them easily
			async getCampaigns(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
				const returnData: INodePropertyOptions[] = [];
				const campaigns = await mailchimpApiRequestAllItems.call(this, '/campaigns', 'GET', 'campaigns');
				for (const campaign of campaigns) {
					const campaignName = campaign.settings.title;
					const campaignId = campaign.id;
					returnData.push({
						name: campaignName,
						value: campaignId,
					});
				}
				return returnData;
			},

			// Get all the available fields to display them to users so that they can select them easily
			async getCampaignsFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
				const returnData: INodePropertyOptions[] = [];
				for (const campaignFields of campaignFieldsMetadata) {
					returnData.push({
						name: campaignFields,
						value: campaignFields,
					});
				}
				return returnData;
			},
		},
	};

	async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
		const items = this.getInputData();
		const returnData: IDataObject[] = [];
		const length = items.length as unknown as number;
		let responseData;
		const qs: IDataObject = {};
		const resource = this.getNodeParameter('resource', 0) as string;
		const operation = this.getNodeParameter('operation', 0) as string;

		for (let i = 0; i < length; i++) {
			try {
				if (resource === 'listGroup') {
					//https://mailchimp.com/developer/reference/lists/interest-categories/#get_/lists/-list_id-/interest-categories/-interest_category_id-
					if (operation === 'getAll') {
						const listId = this.getNodeParameter('list', i) as string;
						const categoryId = this.getNodeParameter('groupCategory', i) as string;
						const returnAll = this.getNodeParameter('returnAll', i) as boolean;

						if (returnAll === true) {
							responseData = await mailchimpApiRequestAllItems.call(this, `/lists/${listId}/interest-categories/${categoryId}/interests`, 'GET', 'interests', {}, qs);
						} else {
							qs.count = this.getNodeParameter('limit', i) as number;
							responseData = await mailchimpApiRequest.call(this, `/lists/${listId}/interest-categories/${categoryId}/interests`, 'GET', {}, qs);
							responseData = responseData.interests;
						}
					}
				}
				if (resource === 'member') {
					//https://mailchimp.com/developer/reference/lists/list-members/#post_/lists/-list_id-/members
					if (operation === 'create') {
						const listId = this.getNodeParameter('list', i) as string;
						const email = this.getNodeParameter('email', i) as string;
						const status = this.getNodeParameter('status', i) as Status;
						const options = this.getNodeParameter('options', i) as IDataObject;
						const jsonActive = this.getNodeParameter('jsonParameters', i) as IDataObject;

						const body: ICreateMemberBody = {
							listId,
							email_address: email,
							status,
						};
						if (options.emailType) {
							body.email_type = options.emailType as string;
						}
						if (options.language) {
							body.language = options.language as string;
						}
						if (options.vip) {
							body.vip = options.vip as boolean;
						}
						if (options.ipSignup) {
							body.ip_signup = options.ipSignup as string;
						}
						if (options.ipOptIn) {
							body.ip_opt = options.ipOptIn as string;
						}
						if (options.timestampOpt) {
							body.timestamp_opt = moment(options.timestampOpt as string).format('YYYY-MM-DD HH:MM:SS') as string;
						}
						if (options.timestampSignup) {
							body.timestamp_signup = moment(options.timestampSignup as string).format('YYYY-MM-DD HH:MM:SS') as string;
						}
						if (options.tags) {
							// @ts-ignore
							body.tags = options.tags.split(',') as string[];
						}
						if (!jsonActive) {
							const locationValues = (this.getNodeParameter('locationFieldsUi', i) as IDataObject).locationFieldsValues as IDataObject;
							if (locationValues) {
								const location: ILocation = {};
								for (const key of Object.keys(locationValues)) {
									if (key === 'latitude') {
										location.latitude = parseFloat(locationValues[key] as string) as number;
									} else if (key === 'longitude') {
										location.longitude = parseFloat(locationValues[key] as string) as number;
									}
								}
								body.location = location;
							}
							const mergeFieldsValues = (this.getNodeParameter('mergeFieldsUi', i) as IDataObject).mergeFieldsValues as IDataObject[];
							if (mergeFieldsValues) {
								const mergeFields = {};
								for (let i = 0; i < mergeFieldsValues.length; i++) {
									// @ts-ignore
									mergeFields[mergeFieldsValues[i].name] = mergeFieldsValues[i].value;
								}
								body.merge_fields = mergeFields;
							}

							const groupsValues = (this.getNodeParameter('groupsUi', i) as IDataObject).groupsValues as IDataObject[];
							if (groupsValues) {
								const groups = {};
								for (let i = 0; i < groupsValues.length; i++) {
									// @ts-ignore
									groups[groupsValues[i].categoryFieldId] = groupsValues[i].value;
								}
								body.interests = groups;
							}
						} else {
							const locationJson = validateJSON(this.getNodeParameter('locationJson', i) as string);
							const mergeFieldsJson = validateJSON(this.getNodeParameter('mergeFieldsJson', i) as string);
							const groupJson = validateJSON(this.getNodeParameter('groupJson', i) as string);
							if (locationJson) {
								body.location = locationJson;
							}
							if (mergeFieldsJson) {
								body.merge_fields = mergeFieldsJson;
							}
							if (groupJson) {
								body.interests = groupJson;
							}
						}
						responseData = await mailchimpApiRequest.call(this, `/lists/${listId}/members`, 'POST', body);
					}
					//https://mailchimp.com/developer/reference/lists/list-members/
					if (operation === 'delete') {

						const listId = this.getNodeParameter('list', i) as string;
						const email = this.getNodeParameter('email', i) as string;

						responseData = await mailchimpApiRequest.call(this, `/lists/${listId}/members/${email}/actions/delete-permanent`, 'POST');
						responseData = { success: true };
					}
					//https://mailchimp.com/developer/reference/lists/list-members/#get_/lists/-list_id-/members/-subscriber_hash-
					if (operation === 'get') {

						const listId = this.getNodeParameter('list', i) as string;
						const email = this.getNodeParameter('email', i) as string;
						const options = this.getNodeParameter('options', i) as IDataObject;

						if (options.fields) {
							qs.fields = options.fields as string;
						}

						if (options.excludeFields) {
							qs.exclude_fields = options.excludeFields as string;
						}

						responseData = await mailchimpApiRequest.call(this, `/lists/${listId}/members/${email}`, 'GET', {}, qs);
					}
					//https://mailchimp.com/developer/reference/lists/list-members/#get_/lists/-list_id-/members
					if (operation === 'getAll') {
						const listId = this.getNodeParameter('list', i) as string;
						const returnAll = this.getNodeParameter('returnAll', i) as boolean;
						const options = this.getNodeParameter('options', i) as IDataObject;

						if (options.beforeLastChanged) {
							qs.before_last_changed = options.beforeLastChanged as string;
						}
						if (options.beforeTimestampOpt) {
							qs.before_timestamp_opt = options.beforeTimestampOpt as string;
						}
						// TODO
						//figure why for some reason when either fields or exclude_fields is set the endpoint returns nothing
						// interestingly it works perfect when retriving just one member

						// if (options.fields) {
						// 	qs.fields = options.fields as string;
						// }
						// if (options.excludeFields) {
						// 	qs.exclude_fields = options.excludeFields as string;
						// }
						if (options.emailType) {
							qs.email_type = options.emailType as string;
						}
						if (options.status) {
							qs.status = options.status as string;
						}
						if (options.sinceLastChanged) {
							qs.since_last_changed = options.sinceLastChanged as string;
						}
						if (returnAll === true) {
							responseData = await mailchimpApiRequestAllItems.call(this, `/lists/${listId}/members`, 'GET', 'members', {}, qs);
						} else {
							qs.count = this.getNodeParameter('limit', i) as number;
							responseData = await mailchimpApiRequest.call(this, `/lists/${listId}/members`, 'GET', {}, qs);
							responseData = responseData.members;
						}
					}
					//https://mailchimp.com/developer/reference/lists/list-members/#put_/lists/-list_id-/members/-subscriber_hash-
					if (operation === 'update') {

						const listId = this.getNodeParameter('list', i) as string;
						const email = this.getNodeParameter('email', i) as string;
						const updateFields = this.getNodeParameter('updateFields', i) as IDataObject;
						const jsonActive = this.getNodeParameter('jsonParameters', i) as IDataObject;
						const body: ICreateMemberBody = {
							listId,
							email_address: email,
						};
						if (updateFields.skipMergeValidation) {
							qs.skip_merge_validation = updateFields.skipMergeValidation as boolean;
						}
						if (updateFields.status) {
							body.status = updateFields.status as Status;
						}
						if (updateFields.emailType) {
							body.email_type = updateFields.emailType as string;
						}
						if (updateFields.language) {
							body.language = updateFields.language as string;
						}
						if (updateFields.vip) {
							body.vip = updateFields.vip as boolean;
						}
						if (updateFields.ipSignup) {
							body.ip_signup = updateFields.ipSignup as string;
						}
						if (updateFields.ipOptIn) {
							body.ip_opt = updateFields.ipOptIn as string;
						}
						if (updateFields.timestampOpt) {
							body.timestamp_opt = moment(updateFields.timestampOpt as string).format('YYYY-MM-DD HH:MM:SS') as string;
						}
						if (updateFields.timestampSignup) {
							body.timestamp_signup = moment(updateFields.timestampSignup as string).format('YYYY-MM-DD HH:MM:SS') as string;
						}
						if (!jsonActive) {
							if (updateFields.locationFieldsUi) {
								const locationValues = (updateFields.locationFieldsUi as IDataObject).locationFieldsValues as IDataObject;
								if (locationValues) {
									const location: ILocation = {};
									for (const key of Object.keys(locationValues)) {
										if (key === 'latitude') {
											location.latitude = parseFloat(locationValues[key] as string) as number;
										} else if (key === 'longitude') {
											location.longitude = parseFloat(locationValues[key] as string) as number;
										}
									}
									body.location = location;
								}
							}
							if (updateFields.mergeFieldsUi) {
								const mergeFieldsValues = (updateFields.mergeFieldsUi as IDataObject).mergeFieldsValues as IDataObject[];
								if (mergeFieldsValues) {
									const mergeFields = {};
									for (let i = 0; i < mergeFieldsValues.length; i++) {
										// @ts-ignore
										mergeFields[mergeFieldsValues[i].name] = mergeFieldsValues[i].value;
									}
									body.merge_fields = mergeFields;
								}
							}
							if (updateFields.groupsUi) {
								const groupsValues = (updateFields.groupsUi  as IDataObject).groupsValues as IDataObject[];
								if (groupsValues) {
									const groups = {};
									for (let i = 0; i < groupsValues.length; i++) {
										// @ts-ignore
										groups[groupsValues[i].categoryFieldId] = groupsValues[i].value;
									}
									body.interests = groups;
								}
							}
						} else {
							const locationJson = validateJSON(this.getNodeParameter('locationJson', i) as string);
							const mergeFieldsJson = validateJSON(this.getNodeParameter('mergeFieldsJson', i) as string);
							const groupJson = validateJSON(this.getNodeParameter('groupJson', i) as string);

							if (locationJson) {
								body.location = locationJson;
							}
							if (mergeFieldsJson) {
								body.merge_fields = mergeFieldsJson;
							}
							if (groupJson) {
								body.interests = groupJson;
							}
						}
						responseData = await mailchimpApiRequest.call(this, `/lists/${listId}/members/${email}`, 'PUT', body);
					}
				}
				if (resource === 'memberTag') {
				//https://mailchimp.com/developer/reference/lists/list-members/list-member-tags/#post_/lists/-list_id-/members/-subscriber_hash-/tags
					if (operation === 'create') {
						const listId = this.getNodeParameter('list', i) as string;
						const email = this.getNodeParameter('email', i) as string;
						const tags = this.getNodeParameter('tags', i) as string[];
						const options = this.getNodeParameter('options', i) as IDataObject;

						const body: IDataObject = {
							tags: [],
						};

						if (options.isSyncing) {
							body.is_syncing = options.isSyncing as boolean;
						}

						for (const tag of tags) {
							//@ts-ignore
							body.tags.push({
								name: tag,
								status: 'active',
							});
						}

						responseData = await mailchimpApiRequest.call(this, `/lists/${listId}/members/${email}/tags`, 'POST', body);
						responseData = { success: true };
					}
				//https://mailchimp.com/developer/reference/lists/list-members/list-member-tags/#post_/lists/-list_id-/members/-subscriber_hash-/tags
					if (operation === 'delete') {

						const listId = this.getNodeParameter('list', i) as string;
						const email = this.getNodeParameter('email', i) as string;
						const tags = this.getNodeParameter('tags', i) as string[];
						const options = this.getNodeParameter('options', i) as IDataObject;

						const body: IDataObject = {
							tags: [],
						};

						if (options.isSyncing) {
							body.is_syncing = options.isSyncing as boolean;
						}

						for (const tag of tags) {
							//@ts-ignore
							body.tags.push({
								name: tag,
								status: 'inactive',
							});
						}
						responseData = await mailchimpApiRequest.call(this, `/lists/${listId}/members/${email}/tags`, 'POST', body);
						responseData = { success: true };
					}
				}
				if (resource === 'campaign') {
					//https://mailchimp.com/developer/api/marketing/campaigns/list-campaigns/
					if (operation === 'getAll') {
						const returnAll = this.getNodeParameter('returnAll', i) as boolean;
						const options = this.getNodeParameter('options', i) as IDataObject;
						if (options.status) {
							qs.status = options.status as string;
						}
						if (options.beforeCreateTime) {
							qs.before_create_time = options.beforeCreateTime as string;
						}
						if (options.beforeSendTime) {
							qs.before_send_time = options.beforeSendTime as string;
						}
						if (options.excludeFields) {
							qs.exclude_fields = (options.exclude_fields as string[]).join(',');
						}
						if (options.fields) {
							qs.fields = (options.fields as string[]).join(',');
							if ((options.fields as string[]).includes('*')) {
								qs.fields = campaignFieldsMetadata.join(',');
							}
						} else {
							qs.fields = [
								'campaigns.id',
								'campaigns.status',
								'campaigns.tracking',
								'campaigns.settings.from_name',
								'campaigns.settings.title',
								'campaigns.settings.reply_to',
							].join(',');
						}

						if (options.listId) {
							qs.list_id = options.listId as string;
						}
						if (options.sinceCreateTime) {
							qs.since_create_time = options.sinceCreateTime as string;
						}
						if (options.sinceSendTime) {
							qs.since_send_time = options.sinceSendTime as string;
						}
						if (options.sortDirection) {
							qs.sort_dir = options.sortDirection as string;
						}
						if (options.sortField) {
							qs.sort_field = options.sortField as string;
						}
						if (returnAll === true) {
							responseData = await mailchimpApiRequestAllItems.call(this, `/campaigns`, 'GET', 'campaigns', {}, qs);
						} else {
							qs.count = this.getNodeParameter('limit', i) as number;
							responseData = await mailchimpApiRequest.call(this, `/campaigns`, 'GET', {}, qs);
							responseData = responseData.campaigns;
						}
					}
					//https://mailchimp.com/developer/api/marketing/campaigns/send-campaign/
					if (operation === 'send') {
						const campaignId = this.getNodeParameter('campaignId', i) as string;
						responseData = await mailchimpApiRequest.call(this, `/campaigns/${campaignId}/actions/send`, 'POST', {});
						responseData = { success: true };
					}
					//https://mailchimp.com/developer/api/marketing/campaigns/get-campaign-info/
					if (operation === 'get') {
						const campaignId = this.getNodeParameter('campaignId', i) as string;
						responseData = await mailchimpApiRequest.call(this, `/campaigns/${campaignId}`, 'GET', {});
					}
					//https://mailchimp.com/developer/api/marketing/campaigns/delete-campaign/
					if (operation === 'delete') {
						const campaignId = this.getNodeParameter('campaignId', i) as string;
						responseData = await mailchimpApiRequest.call(this, `/campaigns/${campaignId}`, 'DELETE', {});
						responseData = { success: true };
					}
					//https://mailchimp.com/developer/api/marketing/campaigns/replicate-campaign/
					if (operation === 'replicate') {
						const campaignId = this.getNodeParameter('campaignId', i) as string;
						responseData = await mailchimpApiRequest.call(this, `/campaigns/${campaignId}/actions/replicate`, 'POST', {});
					}
					//https://mailchimp.com/developer/api/marketing/campaigns/resend-campaign/
					if (operation === 'resend') {
						const campaignId = this.getNodeParameter('campaignId', i) as string;
						responseData = await mailchimpApiRequest.call(this, `/campaigns/${campaignId}/actions/create-resend`, 'POST', {});
					}
				}

				if (Array.isArray(responseData)) {
					returnData.push.apply(returnData, responseData as IDataObject[]);
				} else {
					returnData.push(responseData as IDataObject);
				}
			} catch (error) {
				if (this.continueOnFail()) {
					returnData.push({ error: error.message });
					continue;
				}
				throw error;
			}
		}
		return [this.helpers.returnJsonArray(returnData)];
	}
}