purecloud-platform-client-v2/src/purecloud-platform-client-v2/api/OutboundApi.js

A JavaScript library to interface with the PureCloud Platform API

import ApiClient from '../ApiClient.js';


class OutboundApi {
	/**
	 * Outbound service.
	 * @module purecloud-platform-client-v2/api/OutboundApi
	 * @version 223.0.0
	 */

	/**
	 * Constructs a new OutboundApi. 
	 * @alias module:purecloud-platform-client-v2/api/OutboundApi
	 * @class
	 * @param {module:purecloud-platform-client-v2/ApiClient} apiClient Optional API client implementation to use,
	 * default to {@link module:purecloud-platform-client-v2/ApiClient#instance} if unspecified.
	 */
	constructor(apiClient) {
		this.apiClient = apiClient || ApiClient.instance;
	}


	/**
	 * Delete attempt limits
	 * 
	 * @param {String} attemptLimitsId Attempt limits ID
	 */
	deleteOutboundAttemptlimit(attemptLimitsId) { 
		// verify the required parameter 'attemptLimitsId' is set
		if (attemptLimitsId === undefined || attemptLimitsId === null) {
			throw 'Missing the required parameter "attemptLimitsId" when calling deleteOutboundAttemptlimit';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/attemptlimits/{attemptLimitsId}', 
			'DELETE', 
			{ 'attemptLimitsId': attemptLimitsId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Delete callable time set
	 * 
	 * @param {String} callableTimeSetId Callable Time Set ID
	 */
	deleteOutboundCallabletimeset(callableTimeSetId) { 
		// verify the required parameter 'callableTimeSetId' is set
		if (callableTimeSetId === undefined || callableTimeSetId === null) {
			throw 'Missing the required parameter "callableTimeSetId" when calling deleteOutboundCallabletimeset';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/callabletimesets/{callableTimeSetId}', 
			'DELETE', 
			{ 'callableTimeSetId': callableTimeSetId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Delete a dialer call analysis response set.
	 * 
	 * @param {String} callAnalysisSetId Call Analysis Response Set ID
	 */
	deleteOutboundCallanalysisresponseset(callAnalysisSetId) { 
		// verify the required parameter 'callAnalysisSetId' is set
		if (callAnalysisSetId === undefined || callAnalysisSetId === null) {
			throw 'Missing the required parameter "callAnalysisSetId" when calling deleteOutboundCallanalysisresponseset';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/callanalysisresponsesets/{callAnalysisSetId}', 
			'DELETE', 
			{ 'callAnalysisSetId': callAnalysisSetId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Delete a campaign.
	 * 
	 * @param {String} campaignId Campaign ID
	 */
	deleteOutboundCampaign(campaignId) { 
		// verify the required parameter 'campaignId' is set
		if (campaignId === undefined || campaignId === null) {
			throw 'Missing the required parameter "campaignId" when calling deleteOutboundCampaign';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/campaigns/{campaignId}', 
			'DELETE', 
			{ 'campaignId': campaignId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Reset campaign progress and recycle the campaign
	 * 
	 * @param {String} campaignId Campaign ID
	 */
	deleteOutboundCampaignProgress(campaignId) { 
		// verify the required parameter 'campaignId' is set
		if (campaignId === undefined || campaignId === null) {
			throw 'Missing the required parameter "campaignId" when calling deleteOutboundCampaignProgress';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/campaigns/{campaignId}/progress', 
			'DELETE', 
			{ 'campaignId': campaignId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Delete Campaign Rule
	 * 
	 * @param {String} campaignRuleId Campaign Rule ID
	 */
	deleteOutboundCampaignrule(campaignRuleId) { 
		// verify the required parameter 'campaignRuleId' is set
		if (campaignRuleId === undefined || campaignRuleId === null) {
			throw 'Missing the required parameter "campaignRuleId" when calling deleteOutboundCampaignrule';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/campaignrules/{campaignRuleId}', 
			'DELETE', 
			{ 'campaignRuleId': campaignRuleId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Delete a contact list.
	 * 
	 * @param {String} contactListId ContactList ID
	 */
	deleteOutboundContactlist(contactListId) { 
		// verify the required parameter 'contactListId' is set
		if (contactListId === undefined || contactListId === null) {
			throw 'Missing the required parameter "contactListId" when calling deleteOutboundContactlist';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/contactlists/{contactListId}', 
			'DELETE', 
			{ 'contactListId': contactListId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Delete a contact.
	 * 
	 * @param {String} contactListId Contact List ID
	 * @param {String} contactId Contact ID
	 */
	deleteOutboundContactlistContact(contactListId, contactId) { 
		// verify the required parameter 'contactListId' is set
		if (contactListId === undefined || contactListId === null) {
			throw 'Missing the required parameter "contactListId" when calling deleteOutboundContactlistContact';
		}
		// verify the required parameter 'contactId' is set
		if (contactId === undefined || contactId === null) {
			throw 'Missing the required parameter "contactId" when calling deleteOutboundContactlistContact';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/contactlists/{contactListId}/contacts/{contactId}', 
			'DELETE', 
			{ 'contactListId': contactListId,'contactId': contactId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Delete contacts from a contact list.
	 * 
	 * @param {String} contactListId Contact List ID
	 * @param {Array.<String>} contactIds ContactIds to delete.
	 */
	deleteOutboundContactlistContacts(contactListId, contactIds) { 
		// verify the required parameter 'contactListId' is set
		if (contactListId === undefined || contactListId === null) {
			throw 'Missing the required parameter "contactListId" when calling deleteOutboundContactlistContacts';
		}
		// verify the required parameter 'contactIds' is set
		if (contactIds === undefined || contactIds === null) {
			throw 'Missing the required parameter "contactIds" when calling deleteOutboundContactlistContacts';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/contactlists/{contactListId}/contacts', 
			'DELETE', 
			{ 'contactListId': contactListId },
			{ 'contactIds': this.apiClient.buildCollectionParam(contactIds, 'multi') },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Delete Contact List Filter
	 * 
	 * @param {String} contactListFilterId Contact List Filter ID
	 */
	deleteOutboundContactlistfilter(contactListFilterId) { 
		// verify the required parameter 'contactListFilterId' is set
		if (contactListFilterId === undefined || contactListFilterId === null) {
			throw 'Missing the required parameter "contactListFilterId" when calling deleteOutboundContactlistfilter';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/contactlistfilters/{contactListFilterId}', 
			'DELETE', 
			{ 'contactListFilterId': contactListFilterId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Delete multiple contact lists.
	 * 
	 * @param {Array.<String>} id contact list id(s) to delete
	 */
	deleteOutboundContactlists(id) { 
		// verify the required parameter 'id' is set
		if (id === undefined || id === null) {
			throw 'Missing the required parameter "id" when calling deleteOutboundContactlists';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/contactlists', 
			'DELETE', 
			{  },
			{ 'id': this.apiClient.buildCollectionParam(id, 'multi') },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Delete Contact List Template
	 * 
	 * @param {String} contactListTemplateId ContactListTemplate ID
	 */
	deleteOutboundContactlisttemplate(contactListTemplateId) { 
		// verify the required parameter 'contactListTemplateId' is set
		if (contactListTemplateId === undefined || contactListTemplateId === null) {
			throw 'Missing the required parameter "contactListTemplateId" when calling deleteOutboundContactlisttemplate';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/contactlisttemplates/{contactListTemplateId}', 
			'DELETE', 
			{ 'contactListTemplateId': contactListTemplateId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Delete multiple contact list templates.
	 * 
	 * @param {Array.<String>} id contact list template id(s) to delete
	 */
	deleteOutboundContactlisttemplates(id) { 
		// verify the required parameter 'id' is set
		if (id === undefined || id === null) {
			throw 'Missing the required parameter "id" when calling deleteOutboundContactlisttemplates';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/contactlisttemplates', 
			'DELETE', 
			{  },
			{ 'id': this.apiClient.buildCollectionParam(id, 'multi') },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Delete an Outbound Digital Rule Set
	 * 
	 * @param {String} digitalRuleSetId The Digital Rule Set ID
	 */
	deleteOutboundDigitalruleset(digitalRuleSetId) { 
		// verify the required parameter 'digitalRuleSetId' is set
		if (digitalRuleSetId === undefined || digitalRuleSetId === null) {
			throw 'Missing the required parameter "digitalRuleSetId" when calling deleteOutboundDigitalruleset';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/digitalrulesets/{digitalRuleSetId}', 
			'DELETE', 
			{ 'digitalRuleSetId': digitalRuleSetId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Delete dialer DNC list
	 * 
	 * @param {String} dncListId DncList ID
	 */
	deleteOutboundDnclist(dncListId) { 
		// verify the required parameter 'dncListId' is set
		if (dncListId === undefined || dncListId === null) {
			throw 'Missing the required parameter "dncListId" when calling deleteOutboundDnclist';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/dnclists/{dncListId}', 
			'DELETE', 
			{ 'dncListId': dncListId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Deletes all or expired custom exclusion column entries from a DNC list.
	 * This operation is only for Internal DNC lists of custom exclusion column entries
	 * @param {String} dncListId DncList ID
	 * @param {Object} opts Optional parameters
	 * @param {Boolean} opts.expiredOnly Set to true to only remove DNC entries that are expired (default to false)
	 */
	deleteOutboundDnclistCustomexclusioncolumns(dncListId, opts) { 
		opts = opts || {};
		
		// verify the required parameter 'dncListId' is set
		if (dncListId === undefined || dncListId === null) {
			throw 'Missing the required parameter "dncListId" when calling deleteOutboundDnclistCustomexclusioncolumns';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/dnclists/{dncListId}/customexclusioncolumns', 
			'DELETE', 
			{ 'dncListId': dncListId },
			{ 'expiredOnly': opts['expiredOnly'] },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Deletes all or expired email addresses from a DNC list.
	 * This operation is Only for Internal DNC lists of email addresses
	 * @param {String} dncListId DncList ID
	 * @param {Object} opts Optional parameters
	 * @param {Boolean} opts.expiredOnly Set to true to only remove DNC entries that are expired (default to false)
	 */
	deleteOutboundDnclistEmailaddresses(dncListId, opts) { 
		opts = opts || {};
		
		// verify the required parameter 'dncListId' is set
		if (dncListId === undefined || dncListId === null) {
			throw 'Missing the required parameter "dncListId" when calling deleteOutboundDnclistEmailaddresses';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/dnclists/{dncListId}/emailaddresses', 
			'DELETE', 
			{ 'dncListId': dncListId },
			{ 'expiredOnly': opts['expiredOnly'] },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Deletes all or expired phone numbers from a DNC list.
	 * This operation is Only for Internal DNC lists of phone numbers
	 * @param {String} dncListId DncList ID
	 * @param {Object} opts Optional parameters
	 * @param {Boolean} opts.expiredOnly Set to true to only remove DNC entries that are expired (default to false)
	 */
	deleteOutboundDnclistPhonenumbers(dncListId, opts) { 
		opts = opts || {};
		
		// verify the required parameter 'dncListId' is set
		if (dncListId === undefined || dncListId === null) {
			throw 'Missing the required parameter "dncListId" when calling deleteOutboundDnclistPhonenumbers';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/dnclists/{dncListId}/phonenumbers', 
			'DELETE', 
			{ 'dncListId': dncListId },
			{ 'expiredOnly': opts['expiredOnly'] },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Deletes all or expired whatsApp numbers from a DNC list.
	 * This operation is only for Internal DNC lists of whatsApp numbers
	 * @param {String} dncListId DncList ID
	 * @param {Object} opts Optional parameters
	 * @param {Boolean} opts.expiredOnly Set to true to only remove DNC whatsApp numbers that are expired (default to false)
	 */
	deleteOutboundDnclistWhatsappnumbers(dncListId, opts) { 
		opts = opts || {};
		
		// verify the required parameter 'dncListId' is set
		if (dncListId === undefined || dncListId === null) {
			throw 'Missing the required parameter "dncListId" when calling deleteOutboundDnclistWhatsappnumbers';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/dnclists/{dncListId}/whatsappnumbers', 
			'DELETE', 
			{ 'dncListId': dncListId },
			{ 'expiredOnly': opts['expiredOnly'] },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Delete File Specification Template
	 * 
	 * @param {String} fileSpecificationTemplateId File Specification Template ID
	 */
	deleteOutboundFilespecificationtemplate(fileSpecificationTemplateId) { 
		// verify the required parameter 'fileSpecificationTemplateId' is set
		if (fileSpecificationTemplateId === undefined || fileSpecificationTemplateId === null) {
			throw 'Missing the required parameter "fileSpecificationTemplateId" when calling deleteOutboundFilespecificationtemplate';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/filespecificationtemplates/{fileSpecificationTemplateId}', 
			'DELETE', 
			{ 'fileSpecificationTemplateId': fileSpecificationTemplateId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Delete multiple file specification templates.
	 * 
	 * @param {Array.<String>} id File Specification template id(s) to delete
	 */
	deleteOutboundFilespecificationtemplatesBulk(id) { 
		// verify the required parameter 'id' is set
		if (id === undefined || id === null) {
			throw 'Missing the required parameter "id" when calling deleteOutboundFilespecificationtemplatesBulk';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/filespecificationtemplates/bulk', 
			'DELETE', 
			{  },
			{ 'id': this.apiClient.buildCollectionParam(id, 'multi') },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Delete Import Template
	 * 
	 * @param {String} importTemplateId Import Template ID
	 */
	deleteOutboundImporttemplate(importTemplateId) { 
		// verify the required parameter 'importTemplateId' is set
		if (importTemplateId === undefined || importTemplateId === null) {
			throw 'Missing the required parameter "importTemplateId" when calling deleteOutboundImporttemplate';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/importtemplates/{importTemplateId}', 
			'DELETE', 
			{ 'importTemplateId': importTemplateId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Delete multiple import templates.
	 * 
	 * @param {Array.<String>} id import template id(s) to delete
	 */
	deleteOutboundImporttemplates(id) { 
		// verify the required parameter 'id' is set
		if (id === undefined || id === null) {
			throw 'Missing the required parameter "id" when calling deleteOutboundImporttemplates';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/importtemplates', 
			'DELETE', 
			{  },
			{ 'id': this.apiClient.buildCollectionParam(id, 'multi') },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Delete an Outbound Messaging Campaign
	 * 
	 * @param {String} messagingCampaignId The Messaging Campaign ID
	 */
	deleteOutboundMessagingcampaign(messagingCampaignId) { 
		// verify the required parameter 'messagingCampaignId' is set
		if (messagingCampaignId === undefined || messagingCampaignId === null) {
			throw 'Missing the required parameter "messagingCampaignId" when calling deleteOutboundMessagingcampaign';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/messagingcampaigns/{messagingCampaignId}', 
			'DELETE', 
			{ 'messagingCampaignId': messagingCampaignId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Reset messaging campaign progress and recycle the messaging campaign
	 * Documented permissions are applicable based on campaign type.
	 * @param {String} messagingCampaignId The Messaging Campaign ID
	 */
	deleteOutboundMessagingcampaignProgress(messagingCampaignId) { 
		// verify the required parameter 'messagingCampaignId' is set
		if (messagingCampaignId === undefined || messagingCampaignId === null) {
			throw 'Missing the required parameter "messagingCampaignId" when calling deleteOutboundMessagingcampaignProgress';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/messagingcampaigns/{messagingCampaignId}/progress', 
			'DELETE', 
			{ 'messagingCampaignId': messagingCampaignId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Delete a Rule Set.
	 * 
	 * @param {String} ruleSetId Rule Set ID
	 */
	deleteOutboundRuleset(ruleSetId) { 
		// verify the required parameter 'ruleSetId' is set
		if (ruleSetId === undefined || ruleSetId === null) {
			throw 'Missing the required parameter "ruleSetId" when calling deleteOutboundRuleset';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/rulesets/{ruleSetId}', 
			'DELETE', 
			{ 'ruleSetId': ruleSetId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Delete a dialer campaign schedule.
	 * 
	 * @param {String} campaignId Campaign ID
	 */
	deleteOutboundSchedulesCampaign(campaignId) { 
		// verify the required parameter 'campaignId' is set
		if (campaignId === undefined || campaignId === null) {
			throw 'Missing the required parameter "campaignId" when calling deleteOutboundSchedulesCampaign';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/schedules/campaigns/{campaignId}', 
			'DELETE', 
			{ 'campaignId': campaignId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Delete an email campaign schedule.
	 * 
	 * @param {String} emailCampaignId Email Campaign ID
	 */
	deleteOutboundSchedulesEmailcampaign(emailCampaignId) { 
		// verify the required parameter 'emailCampaignId' is set
		if (emailCampaignId === undefined || emailCampaignId === null) {
			throw 'Missing the required parameter "emailCampaignId" when calling deleteOutboundSchedulesEmailcampaign';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/schedules/emailcampaigns/{emailCampaignId}', 
			'DELETE', 
			{ 'emailCampaignId': emailCampaignId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Delete a messaging campaign schedule.
	 * 
	 * @param {String} messagingCampaignId Messaging Campaign ID
	 */
	deleteOutboundSchedulesMessagingcampaign(messagingCampaignId) { 
		// verify the required parameter 'messagingCampaignId' is set
		if (messagingCampaignId === undefined || messagingCampaignId === null) {
			throw 'Missing the required parameter "messagingCampaignId" when calling deleteOutboundSchedulesMessagingcampaign';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/schedules/messagingcampaigns/{messagingCampaignId}', 
			'DELETE', 
			{ 'messagingCampaignId': messagingCampaignId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Delete a dialer sequence schedule.
	 * 
	 * @param {String} sequenceId Sequence ID
	 */
	deleteOutboundSchedulesSequence(sequenceId) { 
		// verify the required parameter 'sequenceId' is set
		if (sequenceId === undefined || sequenceId === null) {
			throw 'Missing the required parameter "sequenceId" when calling deleteOutboundSchedulesSequence';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/schedules/sequences/{sequenceId}', 
			'DELETE', 
			{ 'sequenceId': sequenceId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Delete a dialer campaign sequence.
	 * 
	 * @param {String} sequenceId Campaign Sequence ID
	 */
	deleteOutboundSequence(sequenceId) { 
		// verify the required parameter 'sequenceId' is set
		if (sequenceId === undefined || sequenceId === null) {
			throw 'Missing the required parameter "sequenceId" when calling deleteOutboundSequence';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/sequences/{sequenceId}', 
			'DELETE', 
			{ 'sequenceId': sequenceId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Get attempt limits
	 * 
	 * @param {String} attemptLimitsId Attempt limits ID
	 */
	getOutboundAttemptlimit(attemptLimitsId) { 
		// verify the required parameter 'attemptLimitsId' is set
		if (attemptLimitsId === undefined || attemptLimitsId === null) {
			throw 'Missing the required parameter "attemptLimitsId" when calling getOutboundAttemptlimit';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/attemptlimits/{attemptLimitsId}', 
			'GET', 
			{ 'attemptLimitsId': attemptLimitsId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Query attempt limits list
	 * 
	 * @param {Object} opts Optional parameters
	 * @param {Number} opts.pageSize Page size. The max that will be returned is 100. (default to 25)
	 * @param {Number} opts.pageNumber Page number (default to 1)
	 * @param {Boolean} opts.allowEmptyResult Whether to return an empty page when there are no results for that page (default to false)
	 * @param {Object} opts.filterType Filter type (default to Prefix)
	 * @param {String} opts.name Name
	 * @param {String} opts.sortBy Sort by
	 * @param {Object} opts.sortOrder Sort order (default to a)
	 */
	getOutboundAttemptlimits(opts) { 
		opts = opts || {};
		

		return this.apiClient.callApi(
			'/api/v2/outbound/attemptlimits', 
			'GET', 
			{  },
			{ 'pageSize': opts['pageSize'],'pageNumber': opts['pageNumber'],'allowEmptyResult': opts['allowEmptyResult'],'filterType': opts['filterType'],'name': opts['name'],'sortBy': opts['sortBy'],'sortOrder': opts['sortOrder'] },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Get callable time set
	 * 
	 * @param {String} callableTimeSetId Callable Time Set ID
	 */
	getOutboundCallabletimeset(callableTimeSetId) { 
		// verify the required parameter 'callableTimeSetId' is set
		if (callableTimeSetId === undefined || callableTimeSetId === null) {
			throw 'Missing the required parameter "callableTimeSetId" when calling getOutboundCallabletimeset';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/callabletimesets/{callableTimeSetId}', 
			'GET', 
			{ 'callableTimeSetId': callableTimeSetId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Query callable time set list
	 * 
	 * @param {Object} opts Optional parameters
	 * @param {Number} opts.pageSize Page size. The max that will be returned is 100. (default to 25)
	 * @param {Number} opts.pageNumber Page number (default to 1)
	 * @param {Boolean} opts.allowEmptyResult Whether to return an empty page when there are no results for that page (default to false)
	 * @param {Object} opts.filterType Filter type (default to Prefix)
	 * @param {String} opts.name Name
	 * @param {String} opts.sortBy Sort by
	 * @param {Object} opts.sortOrder Sort order (default to a)
	 */
	getOutboundCallabletimesets(opts) { 
		opts = opts || {};
		

		return this.apiClient.callApi(
			'/api/v2/outbound/callabletimesets', 
			'GET', 
			{  },
			{ 'pageSize': opts['pageSize'],'pageNumber': opts['pageNumber'],'allowEmptyResult': opts['allowEmptyResult'],'filterType': opts['filterType'],'name': opts['name'],'sortBy': opts['sortBy'],'sortOrder': opts['sortOrder'] },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Get a dialer call analysis response set.
	 * 
	 * @param {String} callAnalysisSetId Call Analysis Response Set ID
	 */
	getOutboundCallanalysisresponseset(callAnalysisSetId) { 
		// verify the required parameter 'callAnalysisSetId' is set
		if (callAnalysisSetId === undefined || callAnalysisSetId === null) {
			throw 'Missing the required parameter "callAnalysisSetId" when calling getOutboundCallanalysisresponseset';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/callanalysisresponsesets/{callAnalysisSetId}', 
			'GET', 
			{ 'callAnalysisSetId': callAnalysisSetId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Query a list of dialer call analysis response sets.
	 * 
	 * @param {Object} opts Optional parameters
	 * @param {Number} opts.pageSize Page size. The max that will be returned is 100. (default to 25)
	 * @param {Number} opts.pageNumber Page number (default to 1)
	 * @param {Boolean} opts.allowEmptyResult Whether to return an empty page when there are no results for that page (default to false)
	 * @param {Object} opts.filterType Filter type (default to Prefix)
	 * @param {String} opts.name Name
	 * @param {String} opts.sortBy Sort by
	 * @param {Object} opts.sortOrder Sort order (default to a)
	 */
	getOutboundCallanalysisresponsesets(opts) { 
		opts = opts || {};
		

		return this.apiClient.callApi(
			'/api/v2/outbound/callanalysisresponsesets', 
			'GET', 
			{  },
			{ 'pageSize': opts['pageSize'],'pageNumber': opts['pageNumber'],'allowEmptyResult': opts['allowEmptyResult'],'filterType': opts['filterType'],'name': opts['name'],'sortBy': opts['sortBy'],'sortOrder': opts['sortOrder'] },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Get dialer campaign.
	 * 
	 * @param {String} campaignId Campaign ID
	 */
	getOutboundCampaign(campaignId) { 
		// verify the required parameter 'campaignId' is set
		if (campaignId === undefined || campaignId === null) {
			throw 'Missing the required parameter "campaignId" when calling getOutboundCampaign';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/campaigns/{campaignId}', 
			'GET', 
			{ 'campaignId': campaignId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Get a preview of how agents will be mapped to this campaign's contact list.
	 * 
	 * @param {String} campaignId Campaign ID
	 */
	getOutboundCampaignAgentownedmappingpreviewResults(campaignId) { 
		// verify the required parameter 'campaignId' is set
		if (campaignId === undefined || campaignId === null) {
			throw 'Missing the required parameter "campaignId" when calling getOutboundCampaignAgentownedmappingpreviewResults';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/campaigns/{campaignId}/agentownedmappingpreview/results', 
			'GET', 
			{ 'campaignId': campaignId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Get campaign diagnostics
	 * 
	 * @param {String} campaignId Campaign ID
	 */
	getOutboundCampaignDiagnostics(campaignId) { 
		// verify the required parameter 'campaignId' is set
		if (campaignId === undefined || campaignId === null) {
			throw 'Missing the required parameter "campaignId" when calling getOutboundCampaignDiagnostics';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/campaigns/{campaignId}/diagnostics', 
			'GET', 
			{ 'campaignId': campaignId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Get dialer campaign interactions.
	 * 
	 * @param {String} campaignId Campaign ID
	 */
	getOutboundCampaignInteractions(campaignId) { 
		// verify the required parameter 'campaignId' is set
		if (campaignId === undefined || campaignId === null) {
			throw 'Missing the required parameter "campaignId" when calling getOutboundCampaignInteractions';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/campaigns/{campaignId}/interactions', 
			'GET', 
			{ 'campaignId': campaignId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Get line distribution information for campaigns using same Edge Group or Site as given campaign
	 * 
	 * @param {String} campaignId Campaign ID
	 * @param {Object} opts Optional parameters
	 * @param {Boolean} opts.includeOnlyActiveCampaigns If true will return only active Campaigns (default to true)
	 * @param {String} opts.edgeGroupId Edge group to be used in line distribution calculations instead of current Campaign's Edge Group. Campaign's Site and Edge Group are mutually exclusive.
	 * @param {String} opts.siteId Site to be used in line distribution calculations instead of current Campaign's Site.  Campaign's Site and Edge Group are mutually exclusive.
	 * @param {Boolean} opts.useWeight Enable usage of weight, this value overrides current Campaign's setting in line distribution calculations
	 * @param {Number} opts.relativeWeight Relative weight to be used in line distribution calculations instead of current Campaign's relative weight
	 * @param {Number} opts.outboundLineCount The number of outbound lines to be used in line distribution calculations, instead of current Campaign's Outbound Lines Count
	 */
	getOutboundCampaignLinedistribution(campaignId, opts) { 
		opts = opts || {};
		
		// verify the required parameter 'campaignId' is set
		if (campaignId === undefined || campaignId === null) {
			throw 'Missing the required parameter "campaignId" when calling getOutboundCampaignLinedistribution';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/campaigns/{campaignId}/linedistribution', 
			'GET', 
			{ 'campaignId': campaignId },
			{ 'includeOnlyActiveCampaigns': opts['includeOnlyActiveCampaigns'],'edgeGroupId': opts['edgeGroupId'],'siteId': opts['siteId'],'useWeight': opts['useWeight'],'relativeWeight': opts['relativeWeight'],'outboundLineCount': opts['outboundLineCount'] },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Get campaign progress
	 * 
	 * @param {String} campaignId Campaign ID
	 */
	getOutboundCampaignProgress(campaignId) { 
		// verify the required parameter 'campaignId' is set
		if (campaignId === undefined || campaignId === null) {
			throw 'Missing the required parameter "campaignId" when calling getOutboundCampaignProgress';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/campaigns/{campaignId}/progress', 
			'GET', 
			{ 'campaignId': campaignId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Get the remaining and total contact count for each skill combination in a skills campaign
	 * 
	 * @param {String} campaignId Campaign ID
	 * @param {Object} opts Optional parameters
	 * @param {Number} opts.pageNumber Page number (default to 1)
	 * @param {Number} opts.pageSize Page size (default to 25)
	 */
	getOutboundCampaignSkillcombinations(campaignId, opts) { 
		opts = opts || {};
		
		// verify the required parameter 'campaignId' is set
		if (campaignId === undefined || campaignId === null) {
			throw 'Missing the required parameter "campaignId" when calling getOutboundCampaignSkillcombinations';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/campaigns/{campaignId}/skillcombinations', 
			'GET', 
			{ 'campaignId': campaignId },
			{ 'pageNumber': opts['pageNumber'],'pageSize': opts['pageSize'] },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Get statistics about a Dialer Campaign
	 * 
	 * @param {String} campaignId Campaign ID
	 */
	getOutboundCampaignStats(campaignId) { 
		// verify the required parameter 'campaignId' is set
		if (campaignId === undefined || campaignId === null) {
			throw 'Missing the required parameter "campaignId" when calling getOutboundCampaignStats';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/campaigns/{campaignId}/stats', 
			'GET', 
			{ 'campaignId': campaignId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Get Campaign Rule
	 * 
	 * @param {String} campaignRuleId Campaign Rule ID
	 */
	getOutboundCampaignrule(campaignRuleId) { 
		// verify the required parameter 'campaignRuleId' is set
		if (campaignRuleId === undefined || campaignRuleId === null) {
			throw 'Missing the required parameter "campaignRuleId" when calling getOutboundCampaignrule';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/campaignrules/{campaignRuleId}', 
			'GET', 
			{ 'campaignRuleId': campaignRuleId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Query Campaign Rule list
	 * 
	 * @param {Object} opts Optional parameters
	 * @param {Number} opts.pageSize Page size. The max that will be returned is 100. (default to 25)
	 * @param {Number} opts.pageNumber Page number (default to 1)
	 * @param {Boolean} opts.allowEmptyResult Whether to return an empty page when there are no results for that page (default to false)
	 * @param {Object} opts.filterType Filter type (default to Prefix)
	 * @param {String} opts.name Name
	 * @param {String} opts.sortBy Sort by
	 * @param {Object} opts.sortOrder Sort order (default to a)
	 */
	getOutboundCampaignrules(opts) { 
		opts = opts || {};
		

		return this.apiClient.callApi(
			'/api/v2/outbound/campaignrules', 
			'GET', 
			{  },
			{ 'pageSize': opts['pageSize'],'pageNumber': opts['pageNumber'],'allowEmptyResult': opts['allowEmptyResult'],'filterType': opts['filterType'],'name': opts['name'],'sortBy': opts['sortBy'],'sortOrder': opts['sortOrder'] },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Query a list of dialer campaigns.
	 * 
	 * @param {Object} opts Optional parameters
	 * @param {Number} opts.pageSize Page size. The max that will be returned is 100. (default to 25)
	 * @param {Number} opts.pageNumber Page number (default to 1)
	 * @param {Object} opts.filterType Filter type (default to Prefix)
	 * @param {String} opts.name Name
	 * @param {Array.<String>} opts.id id
	 * @param {String} opts.contactListId Contact List ID
	 * @param {String} opts.dncListIds DNC list ID
	 * @param {String} opts.distributionQueueId Distribution queue ID
	 * @param {String} opts.edgeGroupId Edge group ID
	 * @param {String} opts.callAnalysisResponseSetId Call analysis response set ID
	 * @param {Array.<String>} opts.divisionId Division ID(s)
	 * @param {String} opts.sortBy Sort by
	 * @param {Object} opts.sortOrder Sort order (default to a)
	 */
	getOutboundCampaigns(opts) { 
		opts = opts || {};
		

		return this.apiClient.callApi(
			'/api/v2/outbound/campaigns', 
			'GET', 
			{  },
			{ 'pageSize': opts['pageSize'],'pageNumber': opts['pageNumber'],'filterType': opts['filterType'],'name': opts['name'],'id': this.apiClient.buildCollectionParam(opts['id'], 'multi'),'contactListId': opts['contactListId'],'dncListIds': opts['dncListIds'],'distributionQueueId': opts['distributionQueueId'],'edgeGroupId': opts['edgeGroupId'],'callAnalysisResponseSetId': opts['callAnalysisResponseSetId'],'divisionId': this.apiClient.buildCollectionParam(opts['divisionId'], 'multi'),'sortBy': opts['sortBy'],'sortOrder': opts['sortOrder'] },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Query across all types of campaigns by division
	 * 
	 * @param {Object} opts Optional parameters
	 * @param {Number} opts.pageSize Page size (default to 25)
	 * @param {Number} opts.pageNumber Page number (default to 1)
	 * @param {Array.<String>} opts.id Campaign ID(s)
	 * @param {String} opts.name Campaign name(s)
	 * @param {Array.<String>} opts.divisionId Division ID(s)
	 * @param {Array.<String>} opts.mediaType Media type(s)
	 * @param {Object} opts.sortOrder Sort order (default to a)
	 */
	getOutboundCampaignsAll(opts) { 
		opts = opts || {};
		

		return this.apiClient.callApi(
			'/api/v2/outbound/campaigns/all', 
			'GET', 
			{  },
			{ 'pageSize': opts['pageSize'],'pageNumber': opts['pageNumber'],'id': this.apiClient.buildCollectionParam(opts['id'], 'multi'),'name': opts['name'],'divisionId': this.apiClient.buildCollectionParam(opts['divisionId'], 'multi'),'mediaType': this.apiClient.buildCollectionParam(opts['mediaType'], 'multi'),'sortOrder': opts['sortOrder'] },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Query across all types of campaigns
	 * 
	 * @param {Object} opts Optional parameters
	 * @param {Number} opts.pageSize Page size (default to 25)
	 * @param {Number} opts.pageNumber Page number (default to 1)
	 * @param {Array.<String>} opts.id Campaign ID(s)
	 * @param {String} opts.name Campaign name(s)
	 * @param {Array.<String>} opts.divisionId Division ID(s)
	 * @param {Array.<String>} opts.mediaType Media type(s)
	 * @param {Object} opts.sortOrder Sort order (default to a)
	 */
	getOutboundCampaignsAllDivisionviews(opts) { 
		opts = opts || {};
		

		return this.apiClient.callApi(
			'/api/v2/outbound/campaigns/all/divisionviews', 
			'GET', 
			{  },
			{ 'pageSize': opts['pageSize'],'pageNumber': opts['pageNumber'],'id': this.apiClient.buildCollectionParam(opts['id'], 'multi'),'name': opts['name'],'divisionId': this.apiClient.buildCollectionParam(opts['divisionId'], 'multi'),'mediaType': this.apiClient.buildCollectionParam(opts['mediaType'], 'multi'),'sortOrder': opts['sortOrder'] },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Get a basic Campaign information object
	 * This returns a simplified version of a Campaign, consisting of name and division.
	 * @param {String} campaignId Campaign ID
	 */
	getOutboundCampaignsDivisionview(campaignId) { 
		// verify the required parameter 'campaignId' is set
		if (campaignId === undefined || campaignId === null) {
			throw 'Missing the required parameter "campaignId" when calling getOutboundCampaignsDivisionview';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/campaigns/divisionviews/{campaignId}', 
			'GET', 
			{ 'campaignId': campaignId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Query a list of basic Campaign information objects
	 * This returns a simplified version of a Campaign, consisting of name and division.
	 * @param {Object} opts Optional parameters
	 * @param {Number} opts.pageSize Page size. The max that will be returned is 100. (default to 25)
	 * @param {Number} opts.pageNumber Page number (default to 1)
	 * @param {Object} opts.filterType Filter type (default to Prefix)
	 * @param {String} opts.name Name
	 * @param {Array.<String>} opts.id id
	 * @param {String} opts.sortBy Sort by
	 * @param {Object} opts.sortOrder Sort order (default to a)
	 */
	getOutboundCampaignsDivisionviews(opts) { 
		opts = opts || {};
		

		return this.apiClient.callApi(
			'/api/v2/outbound/campaigns/divisionviews', 
			'GET', 
			{  },
			{ 'pageSize': opts['pageSize'],'pageNumber': opts['pageNumber'],'filterType': opts['filterType'],'name': opts['name'],'id': this.apiClient.buildCollectionParam(opts['id'], 'multi'),'sortBy': opts['sortBy'],'sortOrder': opts['sortOrder'] },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Get a dialer contact list.
	 * 
	 * @param {String} contactListId ContactList ID
	 * @param {Object} opts Optional parameters
	 * @param {Boolean} opts.includeImportStatus Import status (default to false)
	 * @param {Boolean} opts.includeSize Include size (default to false)
	 */
	getOutboundContactlist(contactListId, opts) { 
		opts = opts || {};
		
		// verify the required parameter 'contactListId' is set
		if (contactListId === undefined || contactListId === null) {
			throw 'Missing the required parameter "contactListId" when calling getOutboundContactlist';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/contactlists/{contactListId}', 
			'GET', 
			{ 'contactListId': contactListId },
			{ 'includeImportStatus': opts['includeImportStatus'],'includeSize': opts['includeSize'] },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Get a contact.
	 * 
	 * @param {String} contactListId Contact List ID
	 * @param {String} contactId Contact ID
	 */
	getOutboundContactlistContact(contactListId, contactId) { 
		// verify the required parameter 'contactListId' is set
		if (contactListId === undefined || contactListId === null) {
			throw 'Missing the required parameter "contactListId" when calling getOutboundContactlistContact';
		}
		// verify the required parameter 'contactId' is set
		if (contactId === undefined || contactId === null) {
			throw 'Missing the required parameter "contactId" when calling getOutboundContactlistContact';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/contactlists/{contactListId}/contacts/{contactId}', 
			'GET', 
			{ 'contactListId': contactListId,'contactId': contactId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Get bulk operation job.
	 * 
	 * @param {String} contactListId Contact List ID
	 * @param {String} jobId Job ID
	 */
	getOutboundContactlistContactsBulkJob(contactListId, jobId) { 
		// verify the required parameter 'contactListId' is set
		if (contactListId === undefined || contactListId === null) {
			throw 'Missing the required parameter "contactListId" when calling getOutboundContactlistContactsBulkJob';
		}
		// verify the required parameter 'jobId' is set
		if (jobId === undefined || jobId === null) {
			throw 'Missing the required parameter "jobId" when calling getOutboundContactlistContactsBulkJob';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/contactlists/{contactListId}/contacts/bulk/jobs/{jobId}', 
			'GET', 
			{ 'contactListId': contactListId,'jobId': jobId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Get 10 most recent bulk operation jobs associated with contact list.
	 * 
	 * @param {String} contactListId Contact List ID
	 */
	getOutboundContactlistContactsBulkJobs(contactListId) { 
		// verify the required parameter 'contactListId' is set
		if (contactListId === undefined || contactListId === null) {
			throw 'Missing the required parameter "contactListId" when calling getOutboundContactlistContactsBulkJobs';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/contactlists/{contactListId}/contacts/bulk/jobs', 
			'GET', 
			{ 'contactListId': contactListId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Get the URI of a contact list export.
	 * 
	 * @param {String} contactListId ContactList ID
	 * @param {Object} opts Optional parameters
	 * @param {String} opts.download Redirect to download uri (default to false)
	 */
	getOutboundContactlistExport(contactListId, opts) { 
		opts = opts || {};
		
		// verify the required parameter 'contactListId' is set
		if (contactListId === undefined || contactListId === null) {
			throw 'Missing the required parameter "contactListId" when calling getOutboundContactlistExport';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/contactlists/{contactListId}/export', 
			'GET', 
			{ 'contactListId': contactListId },
			{ 'download': opts['download'] },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Get dialer contactList import status.
	 * 
	 * @param {String} contactListId ContactList ID
	 */
	getOutboundContactlistImportstatus(contactListId) { 
		// verify the required parameter 'contactListId' is set
		if (contactListId === undefined || contactListId === null) {
			throw 'Missing the required parameter "contactListId" when calling getOutboundContactlistImportstatus';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/contactlists/{contactListId}/importstatus', 
			'GET', 
			{ 'contactListId': contactListId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Preview the result of applying Automatic Time Zone Mapping to a contact list
	 * 
	 * @param {String} contactListId ContactList ID
	 */
	getOutboundContactlistTimezonemappingpreview(contactListId) { 
		// verify the required parameter 'contactListId' is set
		if (contactListId === undefined || contactListId === null) {
			throw 'Missing the required parameter "contactListId" when calling getOutboundContactlistTimezonemappingpreview';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/contactlists/{contactListId}/timezonemappingpreview', 
			'GET', 
			{ 'contactListId': contactListId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Get Contact list filter
	 * 
	 * @param {String} contactListFilterId Contact List Filter ID
	 */
	getOutboundContactlistfilter(contactListFilterId) { 
		// verify the required parameter 'contactListFilterId' is set
		if (contactListFilterId === undefined || contactListFilterId === null) {
			throw 'Missing the required parameter "contactListFilterId" when calling getOutboundContactlistfilter';
		}

		return this.apiClient.callApi(
			'/api/v2/outbound/contactlistfilters/{contactListFilterId}', 
			'GET', 
			{ 'contactListFilterId': contactListFilterId },
			{  },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Query Contact list filters
	 * 
	 * @param {Object} opts Optional parameters
	 * @param {Number} opts.pageSize Page size. The max that will be returned is 100. (default to 25)
	 * @param {Number} opts.pageNumber Page number (default to 1)
	 * @param {Boolean} opts.allowEmptyResult Whether to return an empty page when there are no results for that page (default to false)
	 * @param {Object} opts.filterType Filter type (default to Prefix)
	 * @param {String} opts.name Name
	 * @param {String} opts.sortBy Sort by
	 * @param {Object} opts.sortOrder Sort order (default to a)
	 * @param {String} opts.contactListId Contact List ID
	 */
	getOutboundContactlistfilters(opts) { 
		opts = opts || {};
		

		return this.apiClient.callApi(
			'/api/v2/outbound/contactlistfilters', 
			'GET', 
			{  },
			{ 'pageSize': opts['pageSize'],'pageNumber': opts['pageNumber'],'allowEmptyResult': opts['allowEmptyResult'],'filterType': opts['filterType'],'name': opts['name'],'sortBy': opts['sortBy'],'sortOrder': opts['sortOrder'],'contactListId': opts['contactListId'] },
			{  },
			{  },
			null, 
			['PureCloud OAuth'], 
			['application/json'],
			['application/json']
		);
	}

	/**
	 * Query a list of contact lists.
	 * 
	 * @param {Object} opts Optional parameters
	 * @param {Boolean} opts.includeImportStatus Include import status (default to false)
	 * @param {Boolean} opts.includeSize Include size (