---
title: OutboundApi
---

## PureCloud::OutboundApi

All URIs are relative to *https://api.mypurecloud.com*

Method | Description
------------- | ------------- | -------------
[**delete_outbound_attemptlimit**](OutboundApi.html#delete_outbound_attemptlimit) | Delete attempt limits
[**delete_outbound_callabletimeset**](OutboundApi.html#delete_outbound_callabletimeset) | Delete callable time set
[**delete_outbound_callanalysisresponseset**](OutboundApi.html#delete_outbound_callanalysisresponseset) | Delete a dialer call analysis response set.
[**delete_outbound_campaign**](OutboundApi.html#delete_outbound_campaign) | Delete a campaign.
[**delete_outbound_campaign_progress**](OutboundApi.html#delete_outbound_campaign_progress) | Reset campaign progress and recycle the campaign
[**delete_outbound_campaignrule**](OutboundApi.html#delete_outbound_campaignrule) | Delete Campaign Rule
[**delete_outbound_contactlist**](OutboundApi.html#delete_outbound_contactlist) | Delete a contact list.
[**delete_outbound_contactlist_contact**](OutboundApi.html#delete_outbound_contactlist_contact) | Delete a contact.
[**delete_outbound_contactlist_contacts**](OutboundApi.html#delete_outbound_contactlist_contacts) | Delete contacts from a contact list.
[**delete_outbound_contactlistfilter**](OutboundApi.html#delete_outbound_contactlistfilter) | Delete Contact List Filter
[**delete_outbound_contactlists**](OutboundApi.html#delete_outbound_contactlists) | Delete multiple contact lists.
[**delete_outbound_dnclist**](OutboundApi.html#delete_outbound_dnclist) | Delete dialer DNC list
[**delete_outbound_ruleset**](OutboundApi.html#delete_outbound_ruleset) | Delete a Rule set.
[**delete_outbound_schedules_campaign**](OutboundApi.html#delete_outbound_schedules_campaign) | Delete a dialer campaign schedule.
[**delete_outbound_schedules_sequence**](OutboundApi.html#delete_outbound_schedules_sequence) | Delete a dialer sequence schedule.
[**delete_outbound_sequence**](OutboundApi.html#delete_outbound_sequence) | Delete a dialer campaign sequence.
[**get_outbound_attemptlimit**](OutboundApi.html#get_outbound_attemptlimit) | Get attempt limits
[**get_outbound_attemptlimits**](OutboundApi.html#get_outbound_attemptlimits) | Query attempt limits list
[**get_outbound_callabletimeset**](OutboundApi.html#get_outbound_callabletimeset) | Get callable time set
[**get_outbound_callabletimesets**](OutboundApi.html#get_outbound_callabletimesets) | Query callable time set list
[**get_outbound_callanalysisresponseset**](OutboundApi.html#get_outbound_callanalysisresponseset) | Get a dialer call analysis response set.
[**get_outbound_callanalysisresponsesets**](OutboundApi.html#get_outbound_callanalysisresponsesets) | Query a list of dialer call analysis response sets.
[**get_outbound_campaign**](OutboundApi.html#get_outbound_campaign) | Get dialer campaign.
[**get_outbound_campaign_diagnostics**](OutboundApi.html#get_outbound_campaign_diagnostics) | Get campaign diagnostics
[**get_outbound_campaign_interactions**](OutboundApi.html#get_outbound_campaign_interactions) | Get dialer campaign interactions.
[**get_outbound_campaign_progress**](OutboundApi.html#get_outbound_campaign_progress) | Get campaign progress
[**get_outbound_campaign_stats**](OutboundApi.html#get_outbound_campaign_stats) | Get statistics about a Dialer Campaign
[**get_outbound_campaignrule**](OutboundApi.html#get_outbound_campaignrule) | Get Campaign Rule
[**get_outbound_campaignrules**](OutboundApi.html#get_outbound_campaignrules) | Query Campaign Rule list
[**get_outbound_campaigns**](OutboundApi.html#get_outbound_campaigns) | Query a list of dialer campaigns.
[**get_outbound_contactlist**](OutboundApi.html#get_outbound_contactlist) | Get a dialer contact list.
[**get_outbound_contactlist_contact**](OutboundApi.html#get_outbound_contactlist_contact) | Get a contact.
[**get_outbound_contactlist_export**](OutboundApi.html#get_outbound_contactlist_export) | Get the URI of a contact list export.
[**get_outbound_contactlist_importstatus**](OutboundApi.html#get_outbound_contactlist_importstatus) | Get dialer contactList import status.
[**get_outbound_contactlistfilter**](OutboundApi.html#get_outbound_contactlistfilter) | Get Contact list filter
[**get_outbound_contactlistfilters**](OutboundApi.html#get_outbound_contactlistfilters) | Query Contact list filters
[**get_outbound_contactlists**](OutboundApi.html#get_outbound_contactlists) | Query a list of contact lists.
[**get_outbound_dnclist**](OutboundApi.html#get_outbound_dnclist) | Get dialer DNC list
[**get_outbound_dnclist_export**](OutboundApi.html#get_outbound_dnclist_export) | Get the URI of a DNC list export.
[**get_outbound_dnclist_importstatus**](OutboundApi.html#get_outbound_dnclist_importstatus) | Get dialer dncList import status.
[**get_outbound_dnclists**](OutboundApi.html#get_outbound_dnclists) | Query dialer DNC lists
[**get_outbound_event**](OutboundApi.html#get_outbound_event) | Get Dialer Event
[**get_outbound_events**](OutboundApi.html#get_outbound_events) | Query Event Logs
[**get_outbound_ruleset**](OutboundApi.html#get_outbound_ruleset) | Get a Rule Set by ID.
[**get_outbound_rulesets**](OutboundApi.html#get_outbound_rulesets) | Query a list of Rule Sets.
[**get_outbound_schedules_campaign**](OutboundApi.html#get_outbound_schedules_campaign) | Get a dialer campaign schedule.
[**get_outbound_schedules_campaigns**](OutboundApi.html#get_outbound_schedules_campaigns) | Query for a list of dialer campaign schedules.
[**get_outbound_schedules_sequence**](OutboundApi.html#get_outbound_schedules_sequence) | Get a dialer sequence schedule.
[**get_outbound_schedules_sequences**](OutboundApi.html#get_outbound_schedules_sequences) | Query for a list of dialer sequence schedules.
[**get_outbound_sequence**](OutboundApi.html#get_outbound_sequence) | Get a dialer campaign sequence.
[**get_outbound_sequences**](OutboundApi.html#get_outbound_sequences) | Query a list of dialer campaign sequences.
[**get_outbound_wrapupcodemappings**](OutboundApi.html#get_outbound_wrapupcodemappings) | Get the Dialer wrap up code mapping.
[**post_outbound_attemptlimits**](OutboundApi.html#post_outbound_attemptlimits) | Create attempt limits
[**post_outbound_audits**](OutboundApi.html#post_outbound_audits) | Retrieves audits for dialer.
[**post_outbound_callabletimesets**](OutboundApi.html#post_outbound_callabletimesets) | Create callable time set
[**post_outbound_callanalysisresponsesets**](OutboundApi.html#post_outbound_callanalysisresponsesets) | Create a dialer call analysis response set.
[**post_outbound_campaign_callback_schedule**](OutboundApi.html#post_outbound_campaign_callback_schedule) | Schedule a Callback for a Dialer Campaign (Deprecated)
[**post_outbound_campaignrules**](OutboundApi.html#post_outbound_campaignrules) | Create Campaign Rule
[**post_outbound_campaigns**](OutboundApi.html#post_outbound_campaigns) | Create a campaign.
[**post_outbound_campaigns_progress**](OutboundApi.html#post_outbound_campaigns_progress) | Get progress for a list of campaigns
[**post_outbound_contactlist_contacts**](OutboundApi.html#post_outbound_contactlist_contacts) | Add contacts to a contact list.
[**post_outbound_contactlist_export**](OutboundApi.html#post_outbound_contactlist_export) | Initiate the export of a contact list.
[**post_outbound_contactlistfilters**](OutboundApi.html#post_outbound_contactlistfilters) | Create Contact List Filter
[**post_outbound_contactlistfilters_preview**](OutboundApi.html#post_outbound_contactlistfilters_preview) | Get a preview of the output of a contact list filter
[**post_outbound_contactlists**](OutboundApi.html#post_outbound_contactlists) | Create a contact List.
[**post_outbound_conversation_dnc**](OutboundApi.html#post_outbound_conversation_dnc) | Add phone numbers to a Dialer DNC list.
[**post_outbound_dnclist_export**](OutboundApi.html#post_outbound_dnclist_export) | Initiate the export of a dnc list.
[**post_outbound_dnclist_phonenumbers**](OutboundApi.html#post_outbound_dnclist_phonenumbers) | Add phone numbers to a Dialer DNC list.
[**post_outbound_dnclists**](OutboundApi.html#post_outbound_dnclists) | Create dialer DNC list
[**post_outbound_rulesets**](OutboundApi.html#post_outbound_rulesets) | Create a Dialer Call Analysis Response Set.
[**post_outbound_sequences**](OutboundApi.html#post_outbound_sequences) | Create a new campaign sequence.
[**put_outbound_attemptlimit**](OutboundApi.html#put_outbound_attemptlimit) | Update attempt limits
[**put_outbound_callabletimeset**](OutboundApi.html#put_outbound_callabletimeset) | Update callable time set
[**put_outbound_callanalysisresponseset**](OutboundApi.html#put_outbound_callanalysisresponseset) | Update a dialer call analysis response set.
[**put_outbound_campaign**](OutboundApi.html#put_outbound_campaign) | Update a campaign.
[**put_outbound_campaign_agent**](OutboundApi.html#put_outbound_campaign_agent) | Send notification that an agent's state changed 
[**put_outbound_campaignrule**](OutboundApi.html#put_outbound_campaignrule) | Update Campaign Rule
[**put_outbound_contactlist**](OutboundApi.html#put_outbound_contactlist) | Update a contact list.
[**put_outbound_contactlist_contact**](OutboundApi.html#put_outbound_contactlist_contact) | Update a contact.
[**put_outbound_contactlistfilter**](OutboundApi.html#put_outbound_contactlistfilter) | Update Contact List Filter
[**put_outbound_dnclist**](OutboundApi.html#put_outbound_dnclist) | Update dialer DNC list
[**put_outbound_ruleset**](OutboundApi.html#put_outbound_ruleset) | Update a RuleSet.
[**put_outbound_schedules_campaign**](OutboundApi.html#put_outbound_schedules_campaign) | Update a new campaign schedule.
[**put_outbound_schedules_sequence**](OutboundApi.html#put_outbound_schedules_sequence) | Update a new sequence schedule.
[**put_outbound_sequence**](OutboundApi.html#put_outbound_sequence) | Update a new campaign sequence.
[**put_outbound_wrapupcodemappings**](OutboundApi.html#put_outbound_wrapupcodemappings) | Update the Dialer wrap up code mapping.
{: class="table table-striped"}

<a name="delete_outbound_attemptlimit"></a>

## - delete_outbound_attemptlimit(attempt_limits_id)

Delete attempt limits



Wraps DELETE /api/v2/outbound/attemptlimits/{attemptLimitsId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

attempt_limits_id = "attempt_limits_id_example" # String | Attempt limits ID


begin
  #Delete attempt limits
  api_instance.delete_outbound_attemptlimit(attempt_limits_id)
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->delete_outbound_attemptlimit: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **attempt_limits_id** | **String**| Attempt limits ID |  |
{: class="table table-striped"}


### Return type

nil (empty response body)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="delete_outbound_callabletimeset"></a>

## - delete_outbound_callabletimeset(callable_time_set_id)

Delete callable time set



Wraps DELETE /api/v2/outbound/callabletimesets/{callableTimeSetId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

callable_time_set_id = "callable_time_set_id_example" # String | Callable Time Set ID


begin
  #Delete callable time set
  api_instance.delete_outbound_callabletimeset(callable_time_set_id)
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->delete_outbound_callabletimeset: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **callable_time_set_id** | **String**| Callable Time Set ID |  |
{: class="table table-striped"}


### Return type

nil (empty response body)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="delete_outbound_callanalysisresponseset"></a>

## - delete_outbound_callanalysisresponseset(call_analysis_set_id)

Delete a dialer call analysis response set.



Wraps DELETE /api/v2/outbound/callanalysisresponsesets/{callAnalysisSetId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

call_analysis_set_id = "call_analysis_set_id_example" # String | Call Analysis Response Set ID


begin
  #Delete a dialer call analysis response set.
  api_instance.delete_outbound_callanalysisresponseset(call_analysis_set_id)
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->delete_outbound_callanalysisresponseset: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **call_analysis_set_id** | **String**| Call Analysis Response Set ID |  |
{: class="table table-striped"}


### Return type

nil (empty response body)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="delete_outbound_campaign"></a>

## -[**Campaign**](Campaign.html) delete_outbound_campaign(campaign_id)

Delete a campaign.



Wraps DELETE /api/v2/outbound/campaigns/{campaignId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

campaign_id = "campaign_id_example" # String | Campaign ID


begin
  #Delete a campaign.
  result = api_instance.delete_outbound_campaign(campaign_id)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->delete_outbound_campaign: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **campaign_id** | **String**| Campaign ID |  |
{: class="table table-striped"}


### Return type

[**Campaign**](Campaign.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="delete_outbound_campaign_progress"></a>

## - delete_outbound_campaign_progress(campaign_id)

Reset campaign progress and recycle the campaign



Wraps DELETE /api/v2/outbound/campaigns/{campaignId}/progress 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

campaign_id = "campaign_id_example" # String | Campaign ID


begin
  #Reset campaign progress and recycle the campaign
  api_instance.delete_outbound_campaign_progress(campaign_id)
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->delete_outbound_campaign_progress: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **campaign_id** | **String**| Campaign ID |  |
{: class="table table-striped"}


### Return type

nil (empty response body)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="delete_outbound_campaignrule"></a>

## - delete_outbound_campaignrule(campaign_rule_id)

Delete Campaign Rule



Wraps DELETE /api/v2/outbound/campaignrules/{campaignRuleId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

campaign_rule_id = "campaign_rule_id_example" # String | Campaign Rule ID


begin
  #Delete Campaign Rule
  api_instance.delete_outbound_campaignrule(campaign_rule_id)
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->delete_outbound_campaignrule: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **campaign_rule_id** | **String**| Campaign Rule ID |  |
{: class="table table-striped"}


### Return type

nil (empty response body)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="delete_outbound_contactlist"></a>

## - delete_outbound_contactlist(contact_list_id)

Delete a contact list.



Wraps DELETE /api/v2/outbound/contactlists/{contactListId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

contact_list_id = "contact_list_id_example" # String | ContactList ID


begin
  #Delete a contact list.
  api_instance.delete_outbound_contactlist(contact_list_id)
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->delete_outbound_contactlist: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **contact_list_id** | **String**| ContactList ID |  |
{: class="table table-striped"}


### Return type

nil (empty response body)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="delete_outbound_contactlist_contact"></a>

## - delete_outbound_contactlist_contact(contact_list_id, contact_id)

Delete a contact.



Wraps DELETE /api/v2/outbound/contactlists/{contactListId}/contacts/{contactId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

contact_list_id = "contact_list_id_example" # String | Contact List ID

contact_id = "contact_id_example" # String | Contact ID


begin
  #Delete a contact.
  api_instance.delete_outbound_contactlist_contact(contact_list_id, contact_id)
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->delete_outbound_contactlist_contact: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **contact_list_id** | **String**| Contact List ID |  |
 **contact_id** | **String**| Contact ID |  |
{: class="table table-striped"}


### Return type

nil (empty response body)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="delete_outbound_contactlist_contacts"></a>

## - delete_outbound_contactlist_contacts(contact_list_id, contact_ids)

Delete contacts from a contact list.



Wraps DELETE /api/v2/outbound/contactlists/{contactListId}/contacts 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

contact_list_id = "contact_list_id_example" # String | Contact List ID

contact_ids = ["contact_ids_example"] # Array<String> | ContactIds to delete.


begin
  #Delete contacts from a contact list.
  api_instance.delete_outbound_contactlist_contacts(contact_list_id, contact_ids)
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->delete_outbound_contactlist_contacts: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **contact_list_id** | **String**| Contact List ID |  |
 **contact_ids** | [**Array&lt;String&gt;**](String.html)| ContactIds to delete. |  |
{: class="table table-striped"}


### Return type

nil (empty response body)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="delete_outbound_contactlistfilter"></a>

## - delete_outbound_contactlistfilter(contact_list_filter_id)

Delete Contact List Filter



Wraps DELETE /api/v2/outbound/contactlistfilters/{contactListFilterId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

contact_list_filter_id = "contact_list_filter_id_example" # String | Contact List Filter ID


begin
  #Delete Contact List Filter
  api_instance.delete_outbound_contactlistfilter(contact_list_filter_id)
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->delete_outbound_contactlistfilter: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **contact_list_filter_id** | **String**| Contact List Filter ID |  |
{: class="table table-striped"}


### Return type

nil (empty response body)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="delete_outbound_contactlists"></a>

## - delete_outbound_contactlists(id)

Delete multiple contact lists.



Wraps DELETE /api/v2/outbound/contactlists 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

id = ["id_example"] # Array<String> | contact list id(s) to delete


begin
  #Delete multiple contact lists.
  api_instance.delete_outbound_contactlists(id)
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->delete_outbound_contactlists: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **id** | [**Array&lt;String&gt;**](String.html)| contact list id(s) to delete |  |
{: class="table table-striped"}


### Return type

nil (empty response body)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="delete_outbound_dnclist"></a>

## - delete_outbound_dnclist(dnc_list_id)

Delete dialer DNC list



Wraps DELETE /api/v2/outbound/dnclists/{dncListId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

dnc_list_id = "dnc_list_id_example" # String | DncList ID


begin
  #Delete dialer DNC list
  api_instance.delete_outbound_dnclist(dnc_list_id)
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->delete_outbound_dnclist: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **dnc_list_id** | **String**| DncList ID |  |
{: class="table table-striped"}


### Return type

nil (empty response body)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="delete_outbound_ruleset"></a>

## - delete_outbound_ruleset(rule_set_id)

Delete a Rule set.



Wraps DELETE /api/v2/outbound/rulesets/{ruleSetId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

rule_set_id = "rule_set_id_example" # String | Rule Set ID


begin
  #Delete a Rule set.
  api_instance.delete_outbound_ruleset(rule_set_id)
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->delete_outbound_ruleset: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **rule_set_id** | **String**| Rule Set ID |  |
{: class="table table-striped"}


### Return type

nil (empty response body)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="delete_outbound_schedules_campaign"></a>

## - delete_outbound_schedules_campaign(campaign_id)

Delete a dialer campaign schedule.



Wraps DELETE /api/v2/outbound/schedules/campaigns/{campaignId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

campaign_id = "campaign_id_example" # String | Campaign ID


begin
  #Delete a dialer campaign schedule.
  api_instance.delete_outbound_schedules_campaign(campaign_id)
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->delete_outbound_schedules_campaign: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **campaign_id** | **String**| Campaign ID |  |
{: class="table table-striped"}


### Return type

nil (empty response body)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="delete_outbound_schedules_sequence"></a>

## - delete_outbound_schedules_sequence(sequence_id)

Delete a dialer sequence schedule.



Wraps DELETE /api/v2/outbound/schedules/sequences/{sequenceId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

sequence_id = "sequence_id_example" # String | Sequence ID


begin
  #Delete a dialer sequence schedule.
  api_instance.delete_outbound_schedules_sequence(sequence_id)
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->delete_outbound_schedules_sequence: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **sequence_id** | **String**| Sequence ID |  |
{: class="table table-striped"}


### Return type

nil (empty response body)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="delete_outbound_sequence"></a>

## - delete_outbound_sequence(sequence_id)

Delete a dialer campaign sequence.



Wraps DELETE /api/v2/outbound/sequences/{sequenceId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

sequence_id = "sequence_id_example" # String | Campaign Sequence ID


begin
  #Delete a dialer campaign sequence.
  api_instance.delete_outbound_sequence(sequence_id)
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->delete_outbound_sequence: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **sequence_id** | **String**| Campaign Sequence ID |  |
{: class="table table-striped"}


### Return type

nil (empty response body)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_attemptlimit"></a>

## -[**AttemptLimits**](AttemptLimits.html) get_outbound_attemptlimit(attempt_limits_id)

Get attempt limits



Wraps GET /api/v2/outbound/attemptlimits/{attemptLimitsId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

attempt_limits_id = "attempt_limits_id_example" # String | Attempt limits ID


begin
  #Get attempt limits
  result = api_instance.get_outbound_attemptlimit(attempt_limits_id)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_attemptlimit: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **attempt_limits_id** | **String**| Attempt limits ID |  |
{: class="table table-striped"}


### Return type

[**AttemptLimits**](AttemptLimits.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_attemptlimits"></a>

## -[**AttemptLimitsEntityListing**](AttemptLimitsEntityListing.html) get_outbound_attemptlimits(opts)

Query attempt limits list



Wraps GET /api/v2/outbound/attemptlimits 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

opts = { 
  page_size: 25, # Integer | Page size
  page_number: 1, # Integer | Page number
  filter_type: "Prefix", # String | Filter type
  name: "name_example", # String | Name
  sort_by: "sort_by_example", # String | Sort by
  sort_order: "a" # String | Sort order
}

begin
  #Query attempt limits list
  result = api_instance.get_outbound_attemptlimits(opts)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_attemptlimits: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **page_size** | **Integer**| Page size | [optional] [default to 25] |
 **page_number** | **Integer**| Page number | [optional] [default to 1] |
 **filter_type** | **String**| Filter type | [optional] [default to Prefix]<br />**Values**: Equals, RegEx, Contains, Prefix, LessThan, LessThanEqualTo, GreaterThan, GreaterThanEqualTo, BeginsWith, EndsWith |
 **name** | **String**| Name | [optional]  |
 **sort_by** | **String**| Sort by | [optional]  |
 **sort_order** | **String**| Sort order | [optional] [default to a]<br />**Values**: ascending, descending |
{: class="table table-striped"}


### Return type

[**AttemptLimitsEntityListing**](AttemptLimitsEntityListing.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_callabletimeset"></a>

## -[**CallableTimeSet**](CallableTimeSet.html) get_outbound_callabletimeset(callable_time_set_id)

Get callable time set



Wraps GET /api/v2/outbound/callabletimesets/{callableTimeSetId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

callable_time_set_id = "callable_time_set_id_example" # String | Callable Time Set ID


begin
  #Get callable time set
  result = api_instance.get_outbound_callabletimeset(callable_time_set_id)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_callabletimeset: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **callable_time_set_id** | **String**| Callable Time Set ID |  |
{: class="table table-striped"}


### Return type

[**CallableTimeSet**](CallableTimeSet.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_callabletimesets"></a>

## -[**CallableTimeSetEntityListing**](CallableTimeSetEntityListing.html) get_outbound_callabletimesets(opts)

Query callable time set list



Wraps GET /api/v2/outbound/callabletimesets 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

opts = { 
  page_size: 25, # Integer | Page size
  page_number: 1, # Integer | Page number
  filter_type: "Prefix", # String | Filter type
  name: "name_example", # String | Name
  sort_by: "sort_by_example", # String | Sort by
  sort_order: "a" # String | Sort order
}

begin
  #Query callable time set list
  result = api_instance.get_outbound_callabletimesets(opts)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_callabletimesets: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **page_size** | **Integer**| Page size | [optional] [default to 25] |
 **page_number** | **Integer**| Page number | [optional] [default to 1] |
 **filter_type** | **String**| Filter type | [optional] [default to Prefix]<br />**Values**: Equals, RegEx, Contains, Prefix, LessThan, LessThanEqualTo, GreaterThan, GreaterThanEqualTo, BeginsWith, EndsWith |
 **name** | **String**| Name | [optional]  |
 **sort_by** | **String**| Sort by | [optional]  |
 **sort_order** | **String**| Sort order | [optional] [default to a]<br />**Values**: ascending, descending |
{: class="table table-striped"}


### Return type

[**CallableTimeSetEntityListing**](CallableTimeSetEntityListing.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_callanalysisresponseset"></a>

## -[**ResponseSet**](ResponseSet.html) get_outbound_callanalysisresponseset(call_analysis_set_id)

Get a dialer call analysis response set.



Wraps GET /api/v2/outbound/callanalysisresponsesets/{callAnalysisSetId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

call_analysis_set_id = "call_analysis_set_id_example" # String | Call Analysis Response Set ID


begin
  #Get a dialer call analysis response set.
  result = api_instance.get_outbound_callanalysisresponseset(call_analysis_set_id)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_callanalysisresponseset: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **call_analysis_set_id** | **String**| Call Analysis Response Set ID |  |
{: class="table table-striped"}


### Return type

[**ResponseSet**](ResponseSet.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_callanalysisresponsesets"></a>

## -[**ResponseSetEntityListing**](ResponseSetEntityListing.html) get_outbound_callanalysisresponsesets(opts)

Query a list of dialer call analysis response sets.



Wraps GET /api/v2/outbound/callanalysisresponsesets 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

opts = { 
  page_size: 25, # Integer | Page size
  page_number: 1, # Integer | Page number
  filter_type: "Prefix", # String | Filter type
  name: "name_example", # String | Name
  sort_by: "sort_by_example", # String | Sort by
  sort_order: "a" # String | Sort order
}

begin
  #Query a list of dialer call analysis response sets.
  result = api_instance.get_outbound_callanalysisresponsesets(opts)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_callanalysisresponsesets: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **page_size** | **Integer**| Page size | [optional] [default to 25] |
 **page_number** | **Integer**| Page number | [optional] [default to 1] |
 **filter_type** | **String**| Filter type | [optional] [default to Prefix]<br />**Values**: Equals, RegEx, Contains, Prefix, LessThan, LessThanEqualTo, GreaterThan, GreaterThanEqualTo, BeginsWith, EndsWith |
 **name** | **String**| Name | [optional]  |
 **sort_by** | **String**| Sort by | [optional]  |
 **sort_order** | **String**| Sort order | [optional] [default to a]<br />**Values**: ascending, descending |
{: class="table table-striped"}


### Return type

[**ResponseSetEntityListing**](ResponseSetEntityListing.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_campaign"></a>

## -[**Campaign**](Campaign.html) get_outbound_campaign(campaign_id)

Get dialer campaign.



Wraps GET /api/v2/outbound/campaigns/{campaignId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

campaign_id = "campaign_id_example" # String | Campaign ID


begin
  #Get dialer campaign.
  result = api_instance.get_outbound_campaign(campaign_id)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_campaign: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **campaign_id** | **String**| Campaign ID |  |
{: class="table table-striped"}


### Return type

[**Campaign**](Campaign.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_campaign_diagnostics"></a>

## -[**CampaignDiagnostics**](CampaignDiagnostics.html) get_outbound_campaign_diagnostics(campaign_id)

Get campaign diagnostics



Wraps GET /api/v2/outbound/campaigns/{campaignId}/diagnostics 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

campaign_id = "campaign_id_example" # String | Campaign ID


begin
  #Get campaign diagnostics
  result = api_instance.get_outbound_campaign_diagnostics(campaign_id)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_campaign_diagnostics: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **campaign_id** | **String**| Campaign ID |  |
{: class="table table-striped"}


### Return type

[**CampaignDiagnostics**](CampaignDiagnostics.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_campaign_interactions"></a>

## -[**CampaignInteractions**](CampaignInteractions.html) get_outbound_campaign_interactions(campaign_id)

Get dialer campaign interactions.



Wraps GET /api/v2/outbound/campaigns/{campaignId}/interactions 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

campaign_id = "campaign_id_example" # String | Campaign ID


begin
  #Get dialer campaign interactions.
  result = api_instance.get_outbound_campaign_interactions(campaign_id)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_campaign_interactions: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **campaign_id** | **String**| Campaign ID |  |
{: class="table table-striped"}


### Return type

[**CampaignInteractions**](CampaignInteractions.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_campaign_progress"></a>

## -[**CampaignProgress**](CampaignProgress.html) get_outbound_campaign_progress(campaign_id)

Get campaign progress



Wraps GET /api/v2/outbound/campaigns/{campaignId}/progress 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

campaign_id = "campaign_id_example" # String | Campaign ID


begin
  #Get campaign progress
  result = api_instance.get_outbound_campaign_progress(campaign_id)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_campaign_progress: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **campaign_id** | **String**| Campaign ID |  |
{: class="table table-striped"}


### Return type

[**CampaignProgress**](CampaignProgress.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_campaign_stats"></a>

## -[**CampaignStats**](CampaignStats.html) get_outbound_campaign_stats(campaign_id)

Get statistics about a Dialer Campaign



Wraps GET /api/v2/outbound/campaigns/{campaignId}/stats 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

campaign_id = "campaign_id_example" # String | Campaign ID


begin
  #Get statistics about a Dialer Campaign
  result = api_instance.get_outbound_campaign_stats(campaign_id)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_campaign_stats: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **campaign_id** | **String**| Campaign ID |  |
{: class="table table-striped"}


### Return type

[**CampaignStats**](CampaignStats.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_campaignrule"></a>

## -[**CampaignRule**](CampaignRule.html) get_outbound_campaignrule(campaign_rule_id)

Get Campaign Rule



Wraps GET /api/v2/outbound/campaignrules/{campaignRuleId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

campaign_rule_id = "campaign_rule_id_example" # String | Campaign Rule ID


begin
  #Get Campaign Rule
  result = api_instance.get_outbound_campaignrule(campaign_rule_id)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_campaignrule: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **campaign_rule_id** | **String**| Campaign Rule ID |  |
{: class="table table-striped"}


### Return type

[**CampaignRule**](CampaignRule.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_campaignrules"></a>

## -[**CampaignRuleEntityListing**](CampaignRuleEntityListing.html) get_outbound_campaignrules(opts)

Query Campaign Rule list



Wraps GET /api/v2/outbound/campaignrules 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

opts = { 
  page_size: 25, # Integer | Page size
  page_number: 1, # Integer | Page number
  filter_type: "Prefix", # String | Filter type
  name: "name_example", # String | Name
  sort_by: "sort_by_example", # String | Sort by
  sort_order: "a" # String | Sort order
}

begin
  #Query Campaign Rule list
  result = api_instance.get_outbound_campaignrules(opts)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_campaignrules: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **page_size** | **Integer**| Page size | [optional] [default to 25] |
 **page_number** | **Integer**| Page number | [optional] [default to 1] |
 **filter_type** | **String**| Filter type | [optional] [default to Prefix]<br />**Values**: Equals, RegEx, Contains, Prefix, LessThan, LessThanEqualTo, GreaterThan, GreaterThanEqualTo, BeginsWith, EndsWith |
 **name** | **String**| Name | [optional]  |
 **sort_by** | **String**| Sort by | [optional]  |
 **sort_order** | **String**| Sort order | [optional] [default to a]<br />**Values**: ascending, descending |
{: class="table table-striped"}


### Return type

[**CampaignRuleEntityListing**](CampaignRuleEntityListing.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_campaigns"></a>

## -[**CampaignEntityListing**](CampaignEntityListing.html) get_outbound_campaigns(opts)

Query a list of dialer campaigns.



Wraps GET /api/v2/outbound/campaigns 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

opts = { 
  page_size: 25, # Integer | Page size
  page_number: 1, # Integer | Page number
  filter_type: "Prefix", # String | Filter type
  name: "name_example", # String | Name
  contact_list_id: "contact_list_id_example", # String | Contact List ID
  dnc_list_id: "dnc_list_id_example", # String | DNC list ID
  distribution_queue_id: "distribution_queue_id_example", # String | Distribution queue ID
  edge_group_id: "edge_group_id_example", # String | Edge group ID
  call_analysis_response_set_id: "call_analysis_response_set_id_example", # String | Call analysis response set ID
  sort_by: "sort_by_example", # String | Sort by
  sort_order: "a" # String | Sort order
}

begin
  #Query a list of dialer campaigns.
  result = api_instance.get_outbound_campaigns(opts)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_campaigns: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **page_size** | **Integer**| Page size | [optional] [default to 25] |
 **page_number** | **Integer**| Page number | [optional] [default to 1] |
 **filter_type** | **String**| Filter type | [optional] [default to Prefix]<br />**Values**: Equals, RegEx, Contains, Prefix, LessThan, LessThanEqualTo, GreaterThan, GreaterThanEqualTo, BeginsWith, EndsWith |
 **name** | **String**| Name | [optional]  |
 **contact_list_id** | **String**| Contact List ID | [optional]  |
 **dnc_list_id** | **String**| DNC list ID | [optional]  |
 **distribution_queue_id** | **String**| Distribution queue ID | [optional]  |
 **edge_group_id** | **String**| Edge group ID | [optional]  |
 **call_analysis_response_set_id** | **String**| Call analysis response set ID | [optional]  |
 **sort_by** | **String**| Sort by | [optional]  |
 **sort_order** | **String**| Sort order | [optional] [default to a]<br />**Values**: ascending, descending |
{: class="table table-striped"}


### Return type

[**CampaignEntityListing**](CampaignEntityListing.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_contactlist"></a>

## -[**ContactList**](ContactList.html) get_outbound_contactlist(contact_list_id, opts)

Get a dialer contact list.



Wraps GET /api/v2/outbound/contactlists/{contactListId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

contact_list_id = "contact_list_id_example" # String | ContactList ID

opts = { 
  include_import_status: false, # BOOLEAN | Import status
  include_size: false # BOOLEAN | Include size
}

begin
  #Get a dialer contact list.
  result = api_instance.get_outbound_contactlist(contact_list_id, opts)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_contactlist: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **contact_list_id** | **String**| ContactList ID |  |
 **include_import_status** | **BOOLEAN**| Import status | [optional] [default to false] |
 **include_size** | **BOOLEAN**| Include size | [optional] [default to false] |
{: class="table table-striped"}


### Return type

[**ContactList**](ContactList.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_contactlist_contact"></a>

## -[**DialerContact**](DialerContact.html) get_outbound_contactlist_contact(contact_list_id, contact_id)

Get a contact.



Wraps GET /api/v2/outbound/contactlists/{contactListId}/contacts/{contactId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

contact_list_id = "contact_list_id_example" # String | Contact List ID

contact_id = "contact_id_example" # String | Contact ID


begin
  #Get a contact.
  result = api_instance.get_outbound_contactlist_contact(contact_list_id, contact_id)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_contactlist_contact: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **contact_list_id** | **String**| Contact List ID |  |
 **contact_id** | **String**| Contact ID |  |
{: class="table table-striped"}


### Return type

[**DialerContact**](DialerContact.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_contactlist_export"></a>

## -[**ExportUri**](ExportUri.html) get_outbound_contactlist_export(contact_list_id, opts)

Get the URI of a contact list export.



Wraps GET /api/v2/outbound/contactlists/{contactListId}/export 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

contact_list_id = "contact_list_id_example" # String | ContactList ID

opts = { 
  download: "false" # String | Redirect to download uri
}

begin
  #Get the URI of a contact list export.
  result = api_instance.get_outbound_contactlist_export(contact_list_id, opts)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_contactlist_export: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **contact_list_id** | **String**| ContactList ID |  |
 **download** | **String**| Redirect to download uri | [optional] [default to false] |
{: class="table table-striped"}


### Return type

[**ExportUri**](ExportUri.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_contactlist_importstatus"></a>

## -[**ImportStatus**](ImportStatus.html) get_outbound_contactlist_importstatus(contact_list_id)

Get dialer contactList import status.



Wraps GET /api/v2/outbound/contactlists/{contactListId}/importstatus 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

contact_list_id = "contact_list_id_example" # String | ContactList ID


begin
  #Get dialer contactList import status.
  result = api_instance.get_outbound_contactlist_importstatus(contact_list_id)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_contactlist_importstatus: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **contact_list_id** | **String**| ContactList ID |  |
{: class="table table-striped"}


### Return type

[**ImportStatus**](ImportStatus.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_contactlistfilter"></a>

## -[**ContactListFilter**](ContactListFilter.html) get_outbound_contactlistfilter(contact_list_filter_id)

Get Contact list filter



Wraps GET /api/v2/outbound/contactlistfilters/{contactListFilterId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

contact_list_filter_id = "contact_list_filter_id_example" # String | Contact List Filter ID


begin
  #Get Contact list filter
  result = api_instance.get_outbound_contactlistfilter(contact_list_filter_id)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_contactlistfilter: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **contact_list_filter_id** | **String**| Contact List Filter ID |  |
{: class="table table-striped"}


### Return type

[**ContactListFilter**](ContactListFilter.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_contactlistfilters"></a>

## -[**ContactListFilterEntityListing**](ContactListFilterEntityListing.html) get_outbound_contactlistfilters(opts)

Query Contact list filters



Wraps GET /api/v2/outbound/contactlistfilters 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

opts = { 
  page_size: 25, # Integer | Page size
  page_number: 1, # Integer | Page number
  filter_type: "Prefix", # String | Filter type
  name: "name_example", # String | Name
  sort_by: "sort_by_example", # String | Sort by
  sort_order: "a", # String | Sort order
  contact_list_id: "contact_list_id_example" # String | Contact List ID
}

begin
  #Query Contact list filters
  result = api_instance.get_outbound_contactlistfilters(opts)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_contactlistfilters: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **page_size** | **Integer**| Page size | [optional] [default to 25] |
 **page_number** | **Integer**| Page number | [optional] [default to 1] |
 **filter_type** | **String**| Filter type | [optional] [default to Prefix]<br />**Values**: Equals, RegEx, Contains, Prefix, LessThan, LessThanEqualTo, GreaterThan, GreaterThanEqualTo, BeginsWith, EndsWith |
 **name** | **String**| Name | [optional]  |
 **sort_by** | **String**| Sort by | [optional]  |
 **sort_order** | **String**| Sort order | [optional] [default to a]<br />**Values**: ascending, descending |
 **contact_list_id** | **String**| Contact List ID | [optional]  |
{: class="table table-striped"}


### Return type

[**ContactListFilterEntityListing**](ContactListFilterEntityListing.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_contactlists"></a>

## -[**ContactListEntityListing**](ContactListEntityListing.html) get_outbound_contactlists(opts)

Query a list of contact lists.



Wraps GET /api/v2/outbound/contactlists 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

opts = { 
  include_import_status: false, # BOOLEAN | Include import status
  include_size: false, # BOOLEAN | Include size
  page_size: 25, # Integer | Page size
  page_number: 1, # Integer | Page number
  filter_type: "Prefix", # String | Filter type
  name: "name_example", # String | Name
  sort_by: "sort_by_example", # String | Sort by
  sort_order: "a" # String | Sort order
}

begin
  #Query a list of contact lists.
  result = api_instance.get_outbound_contactlists(opts)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_contactlists: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **include_import_status** | **BOOLEAN**| Include import status | [optional] [default to false] |
 **include_size** | **BOOLEAN**| Include size | [optional] [default to false] |
 **page_size** | **Integer**| Page size | [optional] [default to 25] |
 **page_number** | **Integer**| Page number | [optional] [default to 1] |
 **filter_type** | **String**| Filter type | [optional] [default to Prefix]<br />**Values**: Equals, RegEx, Contains, Prefix, LessThan, LessThanEqualTo, GreaterThan, GreaterThanEqualTo, BeginsWith, EndsWith |
 **name** | **String**| Name | [optional]  |
 **sort_by** | **String**| Sort by | [optional]  |
 **sort_order** | **String**| Sort order | [optional] [default to a]<br />**Values**: ascending, descending |
{: class="table table-striped"}


### Return type

[**ContactListEntityListing**](ContactListEntityListing.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_dnclist"></a>

## -[**DncList**](DncList.html) get_outbound_dnclist(dnc_list_id, opts)

Get dialer DNC list



Wraps GET /api/v2/outbound/dnclists/{dncListId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

dnc_list_id = "dnc_list_id_example" # String | DncList ID

opts = { 
  include_import_status: false, # BOOLEAN | Import status
  include_size: false # BOOLEAN | Include size
}

begin
  #Get dialer DNC list
  result = api_instance.get_outbound_dnclist(dnc_list_id, opts)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_dnclist: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **dnc_list_id** | **String**| DncList ID |  |
 **include_import_status** | **BOOLEAN**| Import status | [optional] [default to false] |
 **include_size** | **BOOLEAN**| Include size | [optional] [default to false] |
{: class="table table-striped"}


### Return type

[**DncList**](DncList.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_dnclist_export"></a>

## -[**ExportUri**](ExportUri.html) get_outbound_dnclist_export(dnc_list_id, opts)

Get the URI of a DNC list export.



Wraps GET /api/v2/outbound/dnclists/{dncListId}/export 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

dnc_list_id = "dnc_list_id_example" # String | DncList ID

opts = { 
  download: "false" # String | Redirect to download uri
}

begin
  #Get the URI of a DNC list export.
  result = api_instance.get_outbound_dnclist_export(dnc_list_id, opts)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_dnclist_export: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **dnc_list_id** | **String**| DncList ID |  |
 **download** | **String**| Redirect to download uri | [optional] [default to false] |
{: class="table table-striped"}


### Return type

[**ExportUri**](ExportUri.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_dnclist_importstatus"></a>

## -[**ImportStatus**](ImportStatus.html) get_outbound_dnclist_importstatus(dnc_list_id)

Get dialer dncList import status.



Wraps GET /api/v2/outbound/dnclists/{dncListId}/importstatus 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

dnc_list_id = "dnc_list_id_example" # String | DncList ID


begin
  #Get dialer dncList import status.
  result = api_instance.get_outbound_dnclist_importstatus(dnc_list_id)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_dnclist_importstatus: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **dnc_list_id** | **String**| DncList ID |  |
{: class="table table-striped"}


### Return type

[**ImportStatus**](ImportStatus.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_dnclists"></a>

## -[**DncListEntityListing**](DncListEntityListing.html) get_outbound_dnclists(opts)

Query dialer DNC lists



Wraps GET /api/v2/outbound/dnclists 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

opts = { 
  include_import_status: false, # BOOLEAN | Import status
  include_size: false, # BOOLEAN | Include size
  page_size: 25, # Integer | Page size
  page_number: 1, # Integer | Page number
  filter_type: "Prefix", # String | Filter type
  name: "name_example", # String | Name
  sort_by: "sort_by_example", # String | Sort by
  sort_order: "sort_order_example" # String | Sort order
}

begin
  #Query dialer DNC lists
  result = api_instance.get_outbound_dnclists(opts)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_dnclists: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **include_import_status** | **BOOLEAN**| Import status | [optional] [default to false] |
 **include_size** | **BOOLEAN**| Include size | [optional] [default to false] |
 **page_size** | **Integer**| Page size | [optional] [default to 25] |
 **page_number** | **Integer**| Page number | [optional] [default to 1] |
 **filter_type** | **String**| Filter type | [optional] [default to Prefix]<br />**Values**: Equals, RegEx, Contains, Prefix, LessThan, LessThanEqualTo, GreaterThan, GreaterThanEqualTo, BeginsWith, EndsWith |
 **name** | **String**| Name | [optional]  |
 **sort_by** | **String**| Sort by | [optional]  |
 **sort_order** | **String**| Sort order | [optional] <br />**Values**: ascending, descending |
{: class="table table-striped"}


### Return type

[**DncListEntityListing**](DncListEntityListing.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_event"></a>

## -[**EventLog**](EventLog.html) get_outbound_event(event_id)

Get Dialer Event



Wraps GET /api/v2/outbound/events/{eventId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

event_id = "event_id_example" # String | Event Log ID


begin
  #Get Dialer Event
  result = api_instance.get_outbound_event(event_id)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_event: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **event_id** | **String**| Event Log ID |  |
{: class="table table-striped"}


### Return type

[**EventLog**](EventLog.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_events"></a>

## -[**DialerEventEntityListing**](DialerEventEntityListing.html) get_outbound_events(opts)

Query Event Logs



Wraps GET /api/v2/outbound/events 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

opts = { 
  page_size: 25, # Integer | Page size
  page_number: 1, # Integer | Page number
  filter_type: "Prefix", # String | Filter type
  category: "category_example", # String | Category
  level: "level_example", # String | Level
  sort_by: "sort_by_example", # String | Sort by
  sort_order: "a" # String | Sort order
}

begin
  #Query Event Logs
  result = api_instance.get_outbound_events(opts)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_events: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **page_size** | **Integer**| Page size | [optional] [default to 25] |
 **page_number** | **Integer**| Page number | [optional] [default to 1] |
 **filter_type** | **String**| Filter type | [optional] [default to Prefix]<br />**Values**: Equals, RegEx, Contains, Prefix, LessThan, LessThanEqualTo, GreaterThan, GreaterThanEqualTo, BeginsWith, EndsWith |
 **category** | **String**| Category | [optional]  |
 **level** | **String**| Level | [optional]  |
 **sort_by** | **String**| Sort by | [optional]  |
 **sort_order** | **String**| Sort order | [optional] [default to a]<br />**Values**: ascending, descending |
{: class="table table-striped"}


### Return type

[**DialerEventEntityListing**](DialerEventEntityListing.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_ruleset"></a>

## -[**RuleSet**](RuleSet.html) get_outbound_ruleset(rule_set_id)

Get a Rule Set by ID.



Wraps GET /api/v2/outbound/rulesets/{ruleSetId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

rule_set_id = "rule_set_id_example" # String | Rule Set ID


begin
  #Get a Rule Set by ID.
  result = api_instance.get_outbound_ruleset(rule_set_id)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_ruleset: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **rule_set_id** | **String**| Rule Set ID |  |
{: class="table table-striped"}


### Return type

[**RuleSet**](RuleSet.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_rulesets"></a>

## -[**RuleSetEntityListing**](RuleSetEntityListing.html) get_outbound_rulesets(opts)

Query a list of Rule Sets.



Wraps GET /api/v2/outbound/rulesets 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

opts = { 
  page_size: 25, # Integer | Page size
  page_number: 1, # Integer | Page number
  filter_type: "Prefix", # String | Filter type
  name: "name_example", # String | Name
  sort_by: "sort_by_example", # String | Sort by
  sort_order: "a" # String | Sort order
}

begin
  #Query a list of Rule Sets.
  result = api_instance.get_outbound_rulesets(opts)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_rulesets: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **page_size** | **Integer**| Page size | [optional] [default to 25] |
 **page_number** | **Integer**| Page number | [optional] [default to 1] |
 **filter_type** | **String**| Filter type | [optional] [default to Prefix]<br />**Values**: Equals, RegEx, Contains, Prefix, LessThan, LessThanEqualTo, GreaterThan, GreaterThanEqualTo, BeginsWith, EndsWith |
 **name** | **String**| Name | [optional]  |
 **sort_by** | **String**| Sort by | [optional]  |
 **sort_order** | **String**| Sort order | [optional] [default to a]<br />**Values**: ascending, descending |
{: class="table table-striped"}


### Return type

[**RuleSetEntityListing**](RuleSetEntityListing.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_schedules_campaign"></a>

## -[**CampaignSchedule**](CampaignSchedule.html) get_outbound_schedules_campaign(campaign_id)

Get a dialer campaign schedule.



Wraps GET /api/v2/outbound/schedules/campaigns/{campaignId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

campaign_id = "campaign_id_example" # String | Campaign ID


begin
  #Get a dialer campaign schedule.
  result = api_instance.get_outbound_schedules_campaign(campaign_id)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_schedules_campaign: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **campaign_id** | **String**| Campaign ID |  |
{: class="table table-striped"}


### Return type

[**CampaignSchedule**](CampaignSchedule.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_schedules_campaigns"></a>

## -[**Array&lt;CampaignSchedule&gt;**](CampaignSchedule.html) get_outbound_schedules_campaigns

Query for a list of dialer campaign schedules.



Wraps GET /api/v2/outbound/schedules/campaigns 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

begin
  #Query for a list of dialer campaign schedules.
  result = api_instance.get_outbound_schedules_campaigns
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_schedules_campaigns: #{e}"
end
~~~

### Parameters
This endpoint does not need any parameter.
{: class="table table-striped"}


### Return type

[**Array&lt;CampaignSchedule&gt;**](CampaignSchedule.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_schedules_sequence"></a>

## -[**SequenceSchedule**](SequenceSchedule.html) get_outbound_schedules_sequence(sequence_id)

Get a dialer sequence schedule.



Wraps GET /api/v2/outbound/schedules/sequences/{sequenceId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

sequence_id = "sequence_id_example" # String | Sequence ID


begin
  #Get a dialer sequence schedule.
  result = api_instance.get_outbound_schedules_sequence(sequence_id)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_schedules_sequence: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **sequence_id** | **String**| Sequence ID |  |
{: class="table table-striped"}


### Return type

[**SequenceSchedule**](SequenceSchedule.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_schedules_sequences"></a>

## -[**Array&lt;SequenceSchedule&gt;**](SequenceSchedule.html) get_outbound_schedules_sequences

Query for a list of dialer sequence schedules.



Wraps GET /api/v2/outbound/schedules/sequences 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

begin
  #Query for a list of dialer sequence schedules.
  result = api_instance.get_outbound_schedules_sequences
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_schedules_sequences: #{e}"
end
~~~

### Parameters
This endpoint does not need any parameter.
{: class="table table-striped"}


### Return type

[**Array&lt;SequenceSchedule&gt;**](SequenceSchedule.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_sequence"></a>

## -[**CampaignSequence**](CampaignSequence.html) get_outbound_sequence(sequence_id)

Get a dialer campaign sequence.



Wraps GET /api/v2/outbound/sequences/{sequenceId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

sequence_id = "sequence_id_example" # String | Campaign Sequence ID


begin
  #Get a dialer campaign sequence.
  result = api_instance.get_outbound_sequence(sequence_id)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_sequence: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **sequence_id** | **String**| Campaign Sequence ID |  |
{: class="table table-striped"}


### Return type

[**CampaignSequence**](CampaignSequence.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_sequences"></a>

## -[**CampaignSequenceEntityListing**](CampaignSequenceEntityListing.html) get_outbound_sequences(opts)

Query a list of dialer campaign sequences.



Wraps GET /api/v2/outbound/sequences 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

opts = { 
  page_size: 25, # Integer | Page size
  page_number: 1, # Integer | Page number
  filter_type: "Prefix", # String | Filter type
  name: "name_example", # String | Name
  sort_by: "sort_by_example", # String | Sort by
  sort_order: "a" # String | Sort order
}

begin
  #Query a list of dialer campaign sequences.
  result = api_instance.get_outbound_sequences(opts)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_sequences: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **page_size** | **Integer**| Page size | [optional] [default to 25] |
 **page_number** | **Integer**| Page number | [optional] [default to 1] |
 **filter_type** | **String**| Filter type | [optional] [default to Prefix]<br />**Values**: Equals, RegEx, Contains, Prefix, LessThan, LessThanEqualTo, GreaterThan, GreaterThanEqualTo, BeginsWith, EndsWith |
 **name** | **String**| Name | [optional]  |
 **sort_by** | **String**| Sort by | [optional]  |
 **sort_order** | **String**| Sort order | [optional] [default to a]<br />**Values**: ascending, descending |
{: class="table table-striped"}


### Return type

[**CampaignSequenceEntityListing**](CampaignSequenceEntityListing.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="get_outbound_wrapupcodemappings"></a>

## -[**WrapUpCodeMapping**](WrapUpCodeMapping.html) get_outbound_wrapupcodemappings

Get the Dialer wrap up code mapping.



Wraps GET /api/v2/outbound/wrapupcodemappings 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

begin
  #Get the Dialer wrap up code mapping.
  result = api_instance.get_outbound_wrapupcodemappings
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->get_outbound_wrapupcodemappings: #{e}"
end
~~~

### Parameters
This endpoint does not need any parameter.
{: class="table table-striped"}


### Return type

[**WrapUpCodeMapping**](WrapUpCodeMapping.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="post_outbound_attemptlimits"></a>

## -[**AttemptLimits**](AttemptLimits.html) post_outbound_attemptlimits(body)

Create attempt limits



Wraps POST /api/v2/outbound/attemptlimits 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

body = PureCloud::AttemptLimits.new # AttemptLimits | AttemptLimits


begin
  #Create attempt limits
  result = api_instance.post_outbound_attemptlimits(body)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->post_outbound_attemptlimits: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **body** | [**AttemptLimits**](AttemptLimits.html)| AttemptLimits |  |
{: class="table table-striped"}


### Return type

[**AttemptLimits**](AttemptLimits.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="post_outbound_audits"></a>

## -[**AuditSearchResult**](AuditSearchResult.html) post_outbound_audits(body, opts)

Retrieves audits for dialer.



Wraps POST /api/v2/outbound/audits 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

body = PureCloud::DialerAuditRequest.new # DialerAuditRequest | AuditSearch

opts = { 
  page_size: 25, # Integer | Page size
  page_number: 1, # Integer | Page number
  sort_by: "entity.name", # String | Sort by
  sort_order: "ascending", # String | Sort order
  facets_only: false # BOOLEAN | Facets only
}

begin
  #Retrieves audits for dialer.
  result = api_instance.post_outbound_audits(body, opts)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->post_outbound_audits: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **body** | [**DialerAuditRequest**](DialerAuditRequest.html)| AuditSearch |  |
 **page_size** | **Integer**| Page size | [optional] [default to 25] |
 **page_number** | **Integer**| Page number | [optional] [default to 1] |
 **sort_by** | **String**| Sort by | [optional] [default to entity.name] |
 **sort_order** | **String**| Sort order | [optional] [default to ascending] |
 **facets_only** | **BOOLEAN**| Facets only | [optional] [default to false] |
{: class="table table-striped"}


### Return type

[**AuditSearchResult**](AuditSearchResult.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="post_outbound_callabletimesets"></a>

## -[**CallableTimeSet**](CallableTimeSet.html) post_outbound_callabletimesets(body)

Create callable time set



Wraps POST /api/v2/outbound/callabletimesets 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

body = PureCloud::CallableTimeSet.new # CallableTimeSet | DialerCallableTimeSet


begin
  #Create callable time set
  result = api_instance.post_outbound_callabletimesets(body)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->post_outbound_callabletimesets: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **body** | [**CallableTimeSet**](CallableTimeSet.html)| DialerCallableTimeSet |  |
{: class="table table-striped"}


### Return type

[**CallableTimeSet**](CallableTimeSet.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="post_outbound_callanalysisresponsesets"></a>

## -[**ResponseSet**](ResponseSet.html) post_outbound_callanalysisresponsesets(body)

Create a dialer call analysis response set.



Wraps POST /api/v2/outbound/callanalysisresponsesets 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

body = PureCloud::ResponseSet.new # ResponseSet | ResponseSet


begin
  #Create a dialer call analysis response set.
  result = api_instance.post_outbound_callanalysisresponsesets(body)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->post_outbound_callanalysisresponsesets: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **body** | [**ResponseSet**](ResponseSet.html)| ResponseSet |  |
{: class="table table-striped"}


### Return type

[**ResponseSet**](ResponseSet.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="post_outbound_campaign_callback_schedule"></a>

## -[**ContactCallbackRequest**](ContactCallbackRequest.html) post_outbound_campaign_callback_schedule(campaign_id, body)

Schedule a Callback for a Dialer Campaign (Deprecated)

This endpoint is deprecated and may have unexpected results. Please use \"/conversations/{conversationId}/participants/{participantId}/callbacks instead.\"

Wraps POST /api/v2/outbound/campaigns/{campaignId}/callback/schedule 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

campaign_id = "campaign_id_example" # String | Campaign ID

body = PureCloud::ContactCallbackRequest.new # ContactCallbackRequest | ContactCallbackRequest


begin
  #Schedule a Callback for a Dialer Campaign (Deprecated)
  result = api_instance.post_outbound_campaign_callback_schedule(campaign_id, body)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->post_outbound_campaign_callback_schedule: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **campaign_id** | **String**| Campaign ID |  |
 **body** | [**ContactCallbackRequest**](ContactCallbackRequest.html)| ContactCallbackRequest |  |
{: class="table table-striped"}


### Return type

[**ContactCallbackRequest**](ContactCallbackRequest.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="post_outbound_campaignrules"></a>

## -[**CampaignRule**](CampaignRule.html) post_outbound_campaignrules(body)

Create Campaign Rule



Wraps POST /api/v2/outbound/campaignrules 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

body = PureCloud::CampaignRule.new # CampaignRule | CampaignRule


begin
  #Create Campaign Rule
  result = api_instance.post_outbound_campaignrules(body)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->post_outbound_campaignrules: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **body** | [**CampaignRule**](CampaignRule.html)| CampaignRule |  |
{: class="table table-striped"}


### Return type

[**CampaignRule**](CampaignRule.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="post_outbound_campaigns"></a>

## -[**Campaign**](Campaign.html) post_outbound_campaigns(body)

Create a campaign.



Wraps POST /api/v2/outbound/campaigns 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

body = PureCloud::Campaign.new # Campaign | Campaign


begin
  #Create a campaign.
  result = api_instance.post_outbound_campaigns(body)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->post_outbound_campaigns: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **body** | [**Campaign**](Campaign.html)| Campaign |  |
{: class="table table-striped"}


### Return type

[**Campaign**](Campaign.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="post_outbound_campaigns_progress"></a>

## -[**Array&lt;CampaignProgress&gt;**](CampaignProgress.html) post_outbound_campaigns_progress(body)

Get progress for a list of campaigns



Wraps POST /api/v2/outbound/campaigns/progress 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

body = [PureCloud::Array<String>.new] # Array<String> | Campaign IDs


begin
  #Get progress for a list of campaigns
  result = api_instance.post_outbound_campaigns_progress(body)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->post_outbound_campaigns_progress: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **body** | **Array&lt;String&gt;**| Campaign IDs |  |
{: class="table table-striped"}


### Return type

[**Array&lt;CampaignProgress&gt;**](CampaignProgress.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="post_outbound_contactlist_contacts"></a>

## -[**Array&lt;DialerContact&gt;**](DialerContact.html) post_outbound_contactlist_contacts(contact_list_id, body, opts)

Add contacts to a contact list.



Wraps POST /api/v2/outbound/contactlists/{contactListId}/contacts 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

contact_list_id = "contact_list_id_example" # String | Contact List ID

body = [PureCloud::DialerContact.new] # Array<DialerContact> | Contact

opts = { 
  priority: true, # BOOLEAN | Contact priority.  True means the contact(s) will be dialed next, false means the contact will go to the end of the contact queue.
  clear_system_data: true # BOOLEAN | Clear system data.  True means the system data stored on the contact will be cleared if the contact already exists (attempts, callable status, etc), false means it won't.
}

begin
  #Add contacts to a contact list.
  result = api_instance.post_outbound_contactlist_contacts(contact_list_id, body, opts)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->post_outbound_contactlist_contacts: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **contact_list_id** | **String**| Contact List ID |  |
 **body** | [**Array&lt;DialerContact&gt;**](DialerContact.html)| Contact |  |
 **priority** | **BOOLEAN**| Contact priority.  True means the contact(s) will be dialed next, false means the contact will go to the end of the contact queue. | [optional]  |
 **clear_system_data** | **BOOLEAN**| Clear system data.  True means the system data stored on the contact will be cleared if the contact already exists (attempts, callable status, etc), false means it won&#39;t. | [optional]  |
{: class="table table-striped"}


### Return type

[**Array&lt;DialerContact&gt;**](DialerContact.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="post_outbound_contactlist_export"></a>

## -[**UriReference**](UriReference.html) post_outbound_contactlist_export(contact_list_id)

Initiate the export of a contact list.

Returns 200 if received OK.

Wraps POST /api/v2/outbound/contactlists/{contactListId}/export 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

contact_list_id = "contact_list_id_example" # String | ContactList ID


begin
  #Initiate the export of a contact list.
  result = api_instance.post_outbound_contactlist_export(contact_list_id)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->post_outbound_contactlist_export: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **contact_list_id** | **String**| ContactList ID |  |
{: class="table table-striped"}


### Return type

[**UriReference**](UriReference.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="post_outbound_contactlistfilters"></a>

## -[**ContactListFilter**](ContactListFilter.html) post_outbound_contactlistfilters(body)

Create Contact List Filter



Wraps POST /api/v2/outbound/contactlistfilters 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

body = PureCloud::ContactListFilter.new # ContactListFilter | ContactListFilter


begin
  #Create Contact List Filter
  result = api_instance.post_outbound_contactlistfilters(body)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->post_outbound_contactlistfilters: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **body** | [**ContactListFilter**](ContactListFilter.html)| ContactListFilter |  |
{: class="table table-striped"}


### Return type

[**ContactListFilter**](ContactListFilter.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="post_outbound_contactlistfilters_preview"></a>

## -[**FilterPreviewResponse**](FilterPreviewResponse.html) post_outbound_contactlistfilters_preview(body)

Get a preview of the output of a contact list filter



Wraps POST /api/v2/outbound/contactlistfilters/preview 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

body = PureCloud::ContactListFilter.new # ContactListFilter | ContactListFilter


begin
  #Get a preview of the output of a contact list filter
  result = api_instance.post_outbound_contactlistfilters_preview(body)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->post_outbound_contactlistfilters_preview: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **body** | [**ContactListFilter**](ContactListFilter.html)| ContactListFilter |  |
{: class="table table-striped"}


### Return type

[**FilterPreviewResponse**](FilterPreviewResponse.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="post_outbound_contactlists"></a>

## -[**ContactList**](ContactList.html) post_outbound_contactlists(body)

Create a contact List.



Wraps POST /api/v2/outbound/contactlists 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

body = PureCloud::ContactList.new # ContactList | ContactList


begin
  #Create a contact List.
  result = api_instance.post_outbound_contactlists(body)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->post_outbound_contactlists: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **body** | [**ContactList**](ContactList.html)| ContactList |  |
{: class="table table-striped"}


### Return type

[**ContactList**](ContactList.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="post_outbound_conversation_dnc"></a>

## - post_outbound_conversation_dnc(conversation_id)

Add phone numbers to a Dialer DNC list.



Wraps POST /api/v2/outbound/conversations/{conversationId}/dnc 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

conversation_id = "conversation_id_example" # String | Conversation ID


begin
  #Add phone numbers to a Dialer DNC list.
  api_instance.post_outbound_conversation_dnc(conversation_id)
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->post_outbound_conversation_dnc: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **conversation_id** | **String**| Conversation ID |  |
{: class="table table-striped"}


### Return type

nil (empty response body)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="post_outbound_dnclist_export"></a>

## -[**UriReference**](UriReference.html) post_outbound_dnclist_export(dnc_list_id)

Initiate the export of a dnc list.

Returns 200 if received OK.

Wraps POST /api/v2/outbound/dnclists/{dncListId}/export 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

dnc_list_id = "dnc_list_id_example" # String | DncList ID


begin
  #Initiate the export of a dnc list.
  result = api_instance.post_outbound_dnclist_export(dnc_list_id)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->post_outbound_dnclist_export: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **dnc_list_id** | **String**| DncList ID |  |
{: class="table table-striped"}


### Return type

[**UriReference**](UriReference.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="post_outbound_dnclist_phonenumbers"></a>

## - post_outbound_dnclist_phonenumbers(dnc_list_id, body)

Add phone numbers to a Dialer DNC list.

Only Internal DNC lists may be appended to

Wraps POST /api/v2/outbound/dnclists/{dncListId}/phonenumbers 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

dnc_list_id = "dnc_list_id_example" # String | DncList ID

body = [PureCloud::Array<String>.new] # Array<String> | DNC Phone Numbers


begin
  #Add phone numbers to a Dialer DNC list.
  api_instance.post_outbound_dnclist_phonenumbers(dnc_list_id, body)
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->post_outbound_dnclist_phonenumbers: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **dnc_list_id** | **String**| DncList ID |  |
 **body** | **Array&lt;String&gt;**| DNC Phone Numbers |  |
{: class="table table-striped"}


### Return type

nil (empty response body)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="post_outbound_dnclists"></a>

## -[**DncList**](DncList.html) post_outbound_dnclists(body)

Create dialer DNC list



Wraps POST /api/v2/outbound/dnclists 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

body = PureCloud::DncListCreate.new # DncListCreate | DncList


begin
  #Create dialer DNC list
  result = api_instance.post_outbound_dnclists(body)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->post_outbound_dnclists: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **body** | [**DncListCreate**](DncListCreate.html)| DncList |  |
{: class="table table-striped"}


### Return type

[**DncList**](DncList.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="post_outbound_rulesets"></a>

## -[**RuleSet**](RuleSet.html) post_outbound_rulesets(body)

Create a Dialer Call Analysis Response Set.



Wraps POST /api/v2/outbound/rulesets 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

body = PureCloud::RuleSet.new # RuleSet | RuleSet


begin
  #Create a Dialer Call Analysis Response Set.
  result = api_instance.post_outbound_rulesets(body)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->post_outbound_rulesets: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **body** | [**RuleSet**](RuleSet.html)| RuleSet |  |
{: class="table table-striped"}


### Return type

[**RuleSet**](RuleSet.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="post_outbound_sequences"></a>

## -[**CampaignSequence**](CampaignSequence.html) post_outbound_sequences(body)

Create a new campaign sequence.



Wraps POST /api/v2/outbound/sequences 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

body = PureCloud::CampaignSequence.new # CampaignSequence | Organization


begin
  #Create a new campaign sequence.
  result = api_instance.post_outbound_sequences(body)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->post_outbound_sequences: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **body** | [**CampaignSequence**](CampaignSequence.html)| Organization |  |
{: class="table table-striped"}


### Return type

[**CampaignSequence**](CampaignSequence.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="put_outbound_attemptlimit"></a>

## -[**AttemptLimits**](AttemptLimits.html) put_outbound_attemptlimit(attempt_limits_id, body)

Update attempt limits



Wraps PUT /api/v2/outbound/attemptlimits/{attemptLimitsId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

attempt_limits_id = "attempt_limits_id_example" # String | Attempt limits ID

body = PureCloud::AttemptLimits.new # AttemptLimits | AttemptLimits


begin
  #Update attempt limits
  result = api_instance.put_outbound_attemptlimit(attempt_limits_id, body)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->put_outbound_attemptlimit: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **attempt_limits_id** | **String**| Attempt limits ID |  |
 **body** | [**AttemptLimits**](AttemptLimits.html)| AttemptLimits |  |
{: class="table table-striped"}


### Return type

[**AttemptLimits**](AttemptLimits.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="put_outbound_callabletimeset"></a>

## -[**CallableTimeSet**](CallableTimeSet.html) put_outbound_callabletimeset(callable_time_set_id, body)

Update callable time set



Wraps PUT /api/v2/outbound/callabletimesets/{callableTimeSetId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

callable_time_set_id = "callable_time_set_id_example" # String | Callable Time Set ID

body = PureCloud::CallableTimeSet.new # CallableTimeSet | DialerCallableTimeSet


begin
  #Update callable time set
  result = api_instance.put_outbound_callabletimeset(callable_time_set_id, body)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->put_outbound_callabletimeset: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **callable_time_set_id** | **String**| Callable Time Set ID |  |
 **body** | [**CallableTimeSet**](CallableTimeSet.html)| DialerCallableTimeSet |  |
{: class="table table-striped"}


### Return type

[**CallableTimeSet**](CallableTimeSet.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="put_outbound_callanalysisresponseset"></a>

## -[**ResponseSet**](ResponseSet.html) put_outbound_callanalysisresponseset(call_analysis_set_id, body)

Update a dialer call analysis response set.



Wraps PUT /api/v2/outbound/callanalysisresponsesets/{callAnalysisSetId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

call_analysis_set_id = "call_analysis_set_id_example" # String | Call Analysis Response Set ID

body = PureCloud::ResponseSet.new # ResponseSet | ResponseSet


begin
  #Update a dialer call analysis response set.
  result = api_instance.put_outbound_callanalysisresponseset(call_analysis_set_id, body)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->put_outbound_callanalysisresponseset: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **call_analysis_set_id** | **String**| Call Analysis Response Set ID |  |
 **body** | [**ResponseSet**](ResponseSet.html)| ResponseSet |  |
{: class="table table-striped"}


### Return type

[**ResponseSet**](ResponseSet.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="put_outbound_campaign"></a>

## -[**Campaign**](Campaign.html) put_outbound_campaign(campaign_id, body)

Update a campaign.



Wraps PUT /api/v2/outbound/campaigns/{campaignId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

campaign_id = "campaign_id_example" # String | Campaign ID

body = PureCloud::Campaign.new # Campaign | Campaign


begin
  #Update a campaign.
  result = api_instance.put_outbound_campaign(campaign_id, body)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->put_outbound_campaign: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **campaign_id** | **String**| Campaign ID |  |
 **body** | [**Campaign**](Campaign.html)| Campaign |  |
{: class="table table-striped"}


### Return type

[**Campaign**](Campaign.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="put_outbound_campaign_agent"></a>

## -String** put_outbound_campaign_agent(campaign_id, user_id, body)

Send notification that an agent's state changed 

New agent state.

Wraps PUT /api/v2/outbound/campaigns/{campaignId}/agents/{userId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

campaign_id = "campaign_id_example" # String | Campaign ID

user_id = "user_id_example" # String | Agent's user ID

body = PureCloud::Agent.new # Agent | agent


begin
  #Send notification that an agent's state changed 
  result = api_instance.put_outbound_campaign_agent(campaign_id, user_id, body)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->put_outbound_campaign_agent: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **campaign_id** | **String**| Campaign ID |  |
 **user_id** | **String**| Agent&#39;s user ID |  |
 **body** | [**Agent**](Agent.html)| agent |  |
{: class="table table-striped"}


### Return type

**String**

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="put_outbound_campaignrule"></a>

## -[**CampaignRule**](CampaignRule.html) put_outbound_campaignrule(campaign_rule_id, body)

Update Campaign Rule



Wraps PUT /api/v2/outbound/campaignrules/{campaignRuleId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

campaign_rule_id = "campaign_rule_id_example" # String | Campaign Rule ID

body = PureCloud::CampaignRule.new # CampaignRule | CampaignRule


begin
  #Update Campaign Rule
  result = api_instance.put_outbound_campaignrule(campaign_rule_id, body)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->put_outbound_campaignrule: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **campaign_rule_id** | **String**| Campaign Rule ID |  |
 **body** | [**CampaignRule**](CampaignRule.html)| CampaignRule |  |
{: class="table table-striped"}


### Return type

[**CampaignRule**](CampaignRule.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="put_outbound_contactlist"></a>

## -[**ContactList**](ContactList.html) put_outbound_contactlist(contact_list_id, body)

Update a contact list.



Wraps PUT /api/v2/outbound/contactlists/{contactListId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

contact_list_id = "contact_list_id_example" # String | ContactList ID

body = PureCloud::ContactList.new # ContactList | ContactList


begin
  #Update a contact list.
  result = api_instance.put_outbound_contactlist(contact_list_id, body)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->put_outbound_contactlist: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **contact_list_id** | **String**| ContactList ID |  |
 **body** | [**ContactList**](ContactList.html)| ContactList |  |
{: class="table table-striped"}


### Return type

[**ContactList**](ContactList.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="put_outbound_contactlist_contact"></a>

## -[**DialerContact**](DialerContact.html) put_outbound_contactlist_contact(contact_list_id, contact_id, body)

Update a contact.



Wraps PUT /api/v2/outbound/contactlists/{contactListId}/contacts/{contactId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

contact_list_id = "contact_list_id_example" # String | Contact List ID

contact_id = "contact_id_example" # String | Contact ID

body = PureCloud::DialerContact.new # DialerContact | Contact


begin
  #Update a contact.
  result = api_instance.put_outbound_contactlist_contact(contact_list_id, contact_id, body)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->put_outbound_contactlist_contact: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **contact_list_id** | **String**| Contact List ID |  |
 **contact_id** | **String**| Contact ID |  |
 **body** | [**DialerContact**](DialerContact.html)| Contact |  |
{: class="table table-striped"}


### Return type

[**DialerContact**](DialerContact.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="put_outbound_contactlistfilter"></a>

## -[**ContactListFilter**](ContactListFilter.html) put_outbound_contactlistfilter(contact_list_filter_id, body)

Update Contact List Filter



Wraps PUT /api/v2/outbound/contactlistfilters/{contactListFilterId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

contact_list_filter_id = "contact_list_filter_id_example" # String | Contact List Filter ID

body = PureCloud::ContactListFilter.new # ContactListFilter | ContactListFilter


begin
  #Update Contact List Filter
  result = api_instance.put_outbound_contactlistfilter(contact_list_filter_id, body)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->put_outbound_contactlistfilter: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **contact_list_filter_id** | **String**| Contact List Filter ID |  |
 **body** | [**ContactListFilter**](ContactListFilter.html)| ContactListFilter |  |
{: class="table table-striped"}


### Return type

[**ContactListFilter**](ContactListFilter.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="put_outbound_dnclist"></a>

## -[**DncList**](DncList.html) put_outbound_dnclist(dnc_list_id, body)

Update dialer DNC list



Wraps PUT /api/v2/outbound/dnclists/{dncListId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

dnc_list_id = "dnc_list_id_example" # String | DncList ID

body = PureCloud::DncList.new # DncList | DncList


begin
  #Update dialer DNC list
  result = api_instance.put_outbound_dnclist(dnc_list_id, body)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->put_outbound_dnclist: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **dnc_list_id** | **String**| DncList ID |  |
 **body** | [**DncList**](DncList.html)| DncList |  |
{: class="table table-striped"}


### Return type

[**DncList**](DncList.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="put_outbound_ruleset"></a>

## -[**RuleSet**](RuleSet.html) put_outbound_ruleset(rule_set_id, body)

Update a RuleSet.



Wraps PUT /api/v2/outbound/rulesets/{ruleSetId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

rule_set_id = "rule_set_id_example" # String | Rule Set ID

body = PureCloud::RuleSet.new # RuleSet | RuleSet


begin
  #Update a RuleSet.
  result = api_instance.put_outbound_ruleset(rule_set_id, body)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->put_outbound_ruleset: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **rule_set_id** | **String**| Rule Set ID |  |
 **body** | [**RuleSet**](RuleSet.html)| RuleSet |  |
{: class="table table-striped"}


### Return type

[**RuleSet**](RuleSet.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="put_outbound_schedules_campaign"></a>

## -[**CampaignSchedule**](CampaignSchedule.html) put_outbound_schedules_campaign(campaign_id, body)

Update a new campaign schedule.



Wraps PUT /api/v2/outbound/schedules/campaigns/{campaignId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

campaign_id = "campaign_id_example" # String | Campaign ID

body = PureCloud::CampaignSchedule.new # CampaignSchedule | CampaignSchedule


begin
  #Update a new campaign schedule.
  result = api_instance.put_outbound_schedules_campaign(campaign_id, body)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->put_outbound_schedules_campaign: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **campaign_id** | **String**| Campaign ID |  |
 **body** | [**CampaignSchedule**](CampaignSchedule.html)| CampaignSchedule |  |
{: class="table table-striped"}


### Return type

[**CampaignSchedule**](CampaignSchedule.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="put_outbound_schedules_sequence"></a>

## -[**SequenceSchedule**](SequenceSchedule.html) put_outbound_schedules_sequence(sequence_id, body)

Update a new sequence schedule.



Wraps PUT /api/v2/outbound/schedules/sequences/{sequenceId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

sequence_id = "sequence_id_example" # String | Sequence ID

body = PureCloud::SequenceSchedule.new # SequenceSchedule | SequenceSchedule


begin
  #Update a new sequence schedule.
  result = api_instance.put_outbound_schedules_sequence(sequence_id, body)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->put_outbound_schedules_sequence: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **sequence_id** | **String**| Sequence ID |  |
 **body** | [**SequenceSchedule**](SequenceSchedule.html)| SequenceSchedule |  |
{: class="table table-striped"}


### Return type

[**SequenceSchedule**](SequenceSchedule.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="put_outbound_sequence"></a>

## -[**CampaignSequence**](CampaignSequence.html) put_outbound_sequence(sequence_id, body)

Update a new campaign sequence.



Wraps PUT /api/v2/outbound/sequences/{sequenceId} 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

sequence_id = "sequence_id_example" # String | Campaign Sequence ID

body = PureCloud::CampaignSequence.new # CampaignSequence | Organization


begin
  #Update a new campaign sequence.
  result = api_instance.put_outbound_sequence(sequence_id, body)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->put_outbound_sequence: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **sequence_id** | **String**| Campaign Sequence ID |  |
 **body** | [**CampaignSequence**](CampaignSequence.html)| Organization |  |
{: class="table table-striped"}


### Return type

[**CampaignSequence**](CampaignSequence.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json



<a name="put_outbound_wrapupcodemappings"></a>

## -[**WrapUpCodeMapping**](WrapUpCodeMapping.html) put_outbound_wrapupcodemappings(body)

Update the Dialer wrap up code mapping.



Wraps PUT /api/v2/outbound/wrapupcodemappings 


### Example
~~~ruby
# load the gem
require 'purecloudplatformclientv2'
# setup authorization
@secret = ENV['PURECLOUD_SECRET']
@id = ENV['PURECLOUD_CLIENT_ID']
environment = "mypurecloud.com"

@authToken = PureCloud.authenticate_with_client_credentials @id, @secret, environment

PureCloud.configure do |config|
  config.access_token = @authToken
end

api_instance = PureCloud::OutboundApi.new

body = PureCloud::WrapUpCodeMapping.new # WrapUpCodeMapping | wrapUpCodeMapping


begin
  #Update the Dialer wrap up code mapping.
  result = api_instance.put_outbound_wrapupcodemappings(body)
  p result
rescue PureCloud::ApiError => e
  puts "Exception when calling OutboundApi->put_outbound_wrapupcodemappings: #{e}"
end
~~~

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **body** | [**WrapUpCodeMapping**](WrapUpCodeMapping.html)| wrapUpCodeMapping |  |
{: class="table table-striped"}


### Return type

[**WrapUpCodeMapping**](WrapUpCodeMapping.html)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json