plivo 4.15.0 → 4.17.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 114dedbc98499312df91e0cdccf82b0965c633a6
-  data.tar.gz: f3e82a94f10e2bfff18d2057d67f639e114e01be
+  metadata.gz: 7e0cf782f59b0fdc5751760de942c004c486b88e
+  data.tar.gz: '059f69a1d0dbba6f854a5d36f9dae7b84f18acaf'
 SHA512:
-  metadata.gz: 22cc46f89d219c32bf3e5f59378b03d383c1737909eed8ef711f0b3e181c3e9e29ee3a1e3b75e146516ac1ac41e4241fe64aaad0c058ebce42982817ad6a151b
-  data.tar.gz: bfd4e2fc9fe8fc548239e34a9d86c319caa45f07df3002b329f1b7210cafd7342bfbc6c5dcbbde0dc01fc9c235b1f6bc053c087a12c486522ecfca9b9d19917a
+  metadata.gz: 2cf38bfcd9981dba0492dbd15fbb7698140a6ff65a58498887289de19d04cac4885fc5468b84e24f3ad80d1232c62af9b80e07def7b64845d0ed92a0592df5f4
+  data.tar.gz: abbcd68c9a8b41abd9a7f5dcad3d0bfdf22dc72ab49f87ade0138dd954d71c95bd1a990f829c90e1c14b1d6c728bb2071eb4b9090833bfe12e7c628233b58872

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Change Log
 
+## [4.17.1](https://github.com/plivo/plivo-ruby/releases/tag/v4.17.1) (2021-06-18)
+- **WARNING**: Remove total_count field from meta data for list MDR response
+
+## [4.17.0](https://github.com/plivo/plivo-ruby/releases/tag/v4.17.0) (2021-06-15)
+- Added stir verification param as part of Get CDR and live call APIs response.
+
+## [4.16.0](https://github.com/plivo/plivo-ruby/releases/tag/v4.16.0) (2021-02-08)
+- Add support for Regulatory Compliance APIs.
+
+## [4.15.2](https://github.com/plivo/plivo-ruby/releases/tag/v4.15.2) (2021-01-27)
+- Fix Call API resource - Set answer_method as Optional param.
+
+## [4.15.1](https://github.com/plivo/plivo-ruby/releases/tag/v4.15.1) (2021-01-06)
+- Fix Search Phone Numbers API using City Attribute.
+
 ## [4.15.0](https://github.com/plivo/plivo-ruby/releases/tag/v4.15.0) (2020-11-17)
 - Add number_priority support for Powerpack API.
 

data/README.md

@@ -8,7 +8,9 @@ The Plivo Ruby SDK makes it simpler to integrate communications into your Ruby a
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'plivo', '>= 4.15.0'
+
+gem 'plivo', '>= 4.17.1'
+
 ```
 
 And then execute:

data/examples/regulatory_compliance.rb

@@ -0,0 +1,167 @@
+require "rubygems"
+require "plivo"
+
+include Plivo
+include Plivo::Exceptions
+
+AUTH_ID = ""
+AUTH_TOKEN = ""
+
+client = RestClient.new(AUTH_ID, AUTH_TOKEN)
+
+# if credentials are stored in the PLIVO_AUTH_ID and the PLIVO_AUTH_TOKEN environment variables
+# then initialize client as:
+# client = RestClient.new
+
+# 1. EndUSers
+begin
+  resp = client.end_users.create('Sample First Name',
+   'Sample last name',
+   'individual')
+  puts resp
+rescue PlivoRESTError => e
+  puts "Exception: " + e.message
+end
+
+
+# Response:
+# {
+#   "api_id": "36989807-a76f-4555-84d1-9dfdccca7a80",
+#   "end_user_id": "36989807-a76f-4555-84d1-9dfdccca7a80",
+#   "name": "Sample First Name",
+#   "last_name": 'Sample last name',
+#   "end_user_type": 'individual',
+#   "created_on": '2021-02-08T05:28:49.238152984Z',
+#   "message": "created"
+# }
+
+# 2. Compliance Document Type
+begin
+    resp = client.compliance_document_types.get('6264e9ee-5826-4f9a-80ce-00b00f7a6c0c')
+    puts resp
+  rescue PlivoRESTError => e
+    puts "Exception: " + e.message
+  end
+
+# Response:
+# {
+#   "api_id": "36989807-a76f-4555-84d1-9dfdccca7a80",
+#   "document_type_id": "36989807-a76f-4555-84d1-9dfdccca7a80",
+#   "document_name": "Address Information",
+#   "description": 'End User Residential Address information',
+#   "information": [
+#      {
+#         "enums": [
+#             "Water",
+#             "Electricity",
+#             "Gas",
+#             "Property Rental",
+#             "Others"
+#         ],
+#         "field_name": "type_of_utility",
+#         "field_type": "enum",
+#         "friendly_name": "Type of Utility"
+#      }
+#   ],
+#   "proof_required": "Scanned copy of the Bill",
+#   "created_at": '2018-11-03 19:32:33.240504+00:00'
+# }
+
+# 3. Compliance Documents
+begin
+    resp = client.compliance_documents.list(
+        limit: 5,
+        offset: 0,
+        document_type_id: '15d48097-6fd6-4bbc-97ee-0c3dd0a8fe1a',
+        end_user_id: '4493840308')
+    puts resp
+  rescue PlivoRESTError => e
+    puts "Exception: " + e.message
+  end
+
+# Response
+#  {
+#    "alias": "test alias",
+#    "api_id": "3cfabf1a-6579-11eb-b408-0242ac110005",
+#    "created_at": "2021-02-02 08:08:10.312992 +0000 UTC",
+#    "document_id": "4a9599cc-c58c-4804-8c04-1d4918cb6df7",
+#    "document_type_id": "be903190-cc96-4fd8-b3cd-97832fe7c086",
+#    "end_user_id": "652e1445-1657-4a80-972f-6dbd467b00b5",
+#    "meta_information": {
+#        "use_case_description": "test"
+#    }
+#}
+
+# 4. Compliance Requirements
+begin
+    resp = client.compliance_requirements.list(
+        country_iso2: 'ES',
+        end_user_type: 'business',
+        number_type: 'local')
+    puts resp
+  rescue PlivoRESTError => e
+    puts "Exception: " + e.message
+  end
+
+# Response:
+#{
+#   "acceptable_document_types": [
+#      {
+#         "acceptable_documents": [
+#            {
+#               "document_type_id": "e68cf5fe-cea0-4b6c-a2b1-bef1d9add467",
+#               "document_type_name": "Address Information"
+#            }
+#          ],
+#          "name": "End User Address Details",
+#          "scope": "local"
+#      },
+#      {
+#         "acceptable_documents": [
+#            {
+#               "document_type_id": "e9b0b6fb-fd2f-44c1-9428-ee69afbd808b",
+#               "document_type_name": "Utility Bill"
+#            }
+#          ],
+#          "name": "Proof of Address ",
+#          "scope": "local"
+#        }
+#    ],
+#    "api_id": "75ea8886-6499-11eb-ad59-0242ac110005",
+#    "compliance_requirement_id": "4ae473b0-f154-41a4-aba8-ab76be12f27f",
+#    "country_iso2": "ES",
+#    "end_user_type": "individual",
+#    "number_type": "local"
+#}
+
+# 5. Compliance Applications
+begin
+    resp = client.compliance_applications.create(
+        alias_: 'test',
+        compliance_requirement_id: '4ae473b0-f154-41a4-aba8-ab76be12f27f',
+        end_user_type: 'individual'
+        end_user_id: 'f7ba78e0-1d31-4f75-842c-cd2f91334d9f',
+        document_ids: ["a663bc92-5c8e-4e95-80d5-ba75d3569a98","4a9599cc-c58c-4804-8c04-1d4918cb6df7"],
+        country_iso2: 'FR',
+        number_type: 'mobile'
+    )
+    puts resp
+  rescue PlivoRESTError => e
+    puts "Exception: " + e.message
+  end
+
+# Response:
+# {
+#   "api_id": "36989807-a76f-4555-84d1-9dfdccca7a80",
+#   "alias": "test",
+#   "compliance_application_id": "7c83fd87-fb5d-4a88-bde0-7c96da35f1e6",
+#   "compliance_requirement_id": "4ae473b0-f154-41a4-aba8-ab76be12f27f",
+#   "country_iso2": "FR",
+#   "documents": [],
+#   "end_user_id": "f7ba78e0-1d31-4f75-842c-cd2f91334d9f",
+#   "end_user_type": "individual",
+#   "message": "created",
+#   "number_type": "local",
+#   "status": "draft",
+#   "created_at": '2021-02-08T19:32:33.240504+00:00'
+# }

data/lib/plivo/base/resource_interface.rb

@@ -59,6 +59,12 @@ module Plivo
         )
       end
 
+      def perform_submit(identifier, params = nil)
+        valid_param?(:identifier, identifier, [String, Symbol], true)
+        response_json = @_client.send_request(@_resource_uri + identifier.to_s + '/Submit/', 'POST', params, nil, false, is_voice_request: @_is_voice_request)
+        @_resource_type.new(@_client, resource_json: response_json)
+      end
+
       def perform_post(params)
         response_json = @_client.send_request(@_resource_uri, 'POST', params, nil, false, is_voice_request: @_is_voice_request)
 

data/lib/plivo/resources.rb

@@ -16,6 +16,7 @@ require_relative 'resources/phlo_member'
 require_relative 'resources/call_feedback'
 require_relative 'resources/media'
 require_relative 'resources/lookup'
+require_relative 'resources/regulatory_compliance'
 
 module Plivo
   module Resources

data/lib/plivo/resources/calls.rb

@@ -230,7 +230,8 @@ module Plivo
           from: @from,
           request_uuid: @request_uuid,
           direction: @direction,
-          caller_name: @caller_name
+          caller_name: @caller_name,
+          stir_verification: @stir_verification
         }
         call_details = call_details.select {|k, v| !v.nil? }
         call_details.to_s
@@ -252,7 +253,6 @@ module Plivo
       # @param [String] from
       # @param [Array] to
       # @param [String] answer_url
-      # @param [String] answer_method
       # @param [Hash] options
       # @option options [String] :answer_method - The method used to call the answer_url. Defaults to POST.
       # @option options [String] :ring_url - The URL that is notified by Plivo when the call is ringing. Defaults not set.
@@ -275,21 +275,19 @@ module Plivo
       # @option options [String] :parent_call_uuid - The call_uuid of the first leg in an ongoing conference call. It is recommended to use this parameter in scenarios where a member who is already present in the conference intends to add new members by initiating outbound API calls. This minimizes the delay in adding a new memeber to the conference.
       # @option options [Boolean] :error_parent_not_found - if set to true and the parent_call_uuid cannot be found, the API request would return an error. If set to false, the outbound call API request will be executed even if the parent_call_uuid is not found. Defaults to false.
       # @return [Call] Call
-      def create(from, to, answer_url, answer_method = 'POST', options = nil)
+      def create(from, to, answer_url, options = nil) 
         valid_param?(:from, from, [String, Symbol, Integer], true)
         valid_param?(:to, to, Array, true)
         to.each do |to_num|
           valid_param?(:to_num, to_num, [Integer, String, Symbol], true)
         end
         valid_param?(:answer_url, answer_url, [String, Symbol], true)
-        valid_param?(:answer_method, answer_method, [String, Symbol],
-                     true, %w[GET POST])
+      
 
         params = {
           from: from,
           to: to.join('<'),
           answer_url: answer_url,
-          answer_method: answer_method
         }
 
         return perform_create(params, false) if options.nil?

data/lib/plivo/resources/numbers.rb

@@ -59,6 +59,7 @@ module Plivo
       #                                    - By default, numbers that have either voice or sms or both enabled are returned.
       # @option options [String] :lata Numbers can be searched using Local Access and Transport Area {http://en.wikipedia.org/wiki/Local_access_and_transport_area}. This filter is applicable only for country_iso US and CA.
       # @option options [String] :rate_center Numbers can be searched using Rate Center {http://en.wikipedia.org/wiki/Telephone_exchange}. This filter is application only for country_iso US and CA.
+      # @option options [String] :city Filter phone number based on the city name. This filter is only applicable when the type is Local
       # @option options [Boolean] :eligible If set to true, lists only those numbers that you are eligible to buy at the moment. To list all numbers, ignore this option.
       # @option options [Int] :limit Used to display the number of results per page. The maximum number of results that can be fetched is 20.
       # @option options [Int] :offset Denotes the number of value items by which the results should be offset. Eg:- If the result contains a 1000 values and limit is set to 10 and offset is set to 705, then values 706 through 715 are displayed in the results. This parameter is also used for pagination of the results.
@@ -71,7 +72,7 @@ module Plivo
 
         return perform_list(params) if options.nil?
 
-        %i[type pattern region services lata rate_center].each do |param|
+        %i[type pattern region services lata rate_center city].each do |param|
           if options.key?(param) &&
              valid_param?(param, options[param], [String, Symbol], true)
             params[param] = options[param]

data/lib/plivo/resources/regulatory_compliance.rb

@@ -0,0 +1,610 @@
+module Plivo
+  module Resources
+    include Plivo::Utils
+
+    class EndUser < Base::Resource
+      def initialize(client, options = nil)
+        @_name = 'EndUser'
+        @_identifier_string = 'end_user'
+        super
+      end
+
+      def update(options = nil)
+        return perform_update({}) if options.nil?
+
+        valid_param?(:options, options, Hash, true)
+
+        params = {}
+        params_expected = %i[ name last_name ]
+        params_expected.each do |param|
+          if options.key?(param) &&
+             valid_param?(param, options[param], [String, Symbol], false)
+            params[param] = options[param]
+          end
+        end
+
+        if options.key?(:end_user_type) &&
+          valid_param?(:end_user_type, options[:end_user_type].capitalize,[String, Symbol], false,  %w[Business Individual])
+          params[:end_user_type] = options[:end_user_type].capitalize
+        end
+
+        perform_update(params)
+      end
+
+      def delete
+        perform_delete
+      end
+
+      def to_s
+        {
+          api_id: @api_id,
+          end_user_id: @end_user_id,
+          end_user_type: @end_user_type,
+          name: @name,
+          last_name: @last_name,
+          created_at: @created_at
+        }.delete_if { |key, value| value.nil? }.to_s
+      end
+    end
+
+    class EndUsersInterface < Base::ResourceInterface
+      def initialize(client, resource_list_json = nil)
+        @_name = 'EndUser'
+        @_resource_type = EndUser
+        @_identifier_string = 'end_user'
+        super
+      end
+
+      ##
+      # Get an EndUser
+      # @param [String] end_user_id
+      # return [EndUser]
+      def get(end_user_id)
+        valid_param?(:end_user_id, end_user_id, [String, Symbol], true)
+        perform_get(end_user_id)
+      end
+
+      ##
+      # List all EndUser
+      # @param [Hash] options
+      # @option options [Int] :offset
+      # @option options [Int] :limit
+      # @return [Hash]
+      def list(options = nil)
+        return perform_list if options.nil?
+        valid_param?(:options, options, Hash, true)
+
+        params = {}
+        params_expected = %i[ name last_name ]
+        params_expected.each do |param|
+          if options.key?(param) &&
+             valid_param?(param, options[param], [String, Symbol], false)
+            params[param] = options[param]
+          end
+        end
+
+        if options.key?(:end_user_type) &&
+          valid_param?(:end_user_type, options[:end_user_type].capitalize,[String, Symbol], false,  %w[Business Individual])
+          params[:end_user_type] = options[:end_user_type].capitalize
+        end
+
+        %i[offset limit].each do |param|
+          if options.key?(param) && valid_param?(param, options[param],
+                                                 [Integer], true)
+            params[param] = options[param]
+          end
+        end
+
+        raise_invalid_request("Offset can't be negative") if options.key?(:offset) && options[:offset] < 0
+
+        if options.key?(:limit) && (options[:limit] > 20 || options[:limit] <= 0)
+          raise_invalid_request('The maximum number of results that can be '\
+          "fetched is 20. limit can't be more than 20 or less than 1")
+        end
+
+        perform_list(params)
+      end
+
+      ##
+      # Create an EndUser
+      # @param [String] name
+      # @param [String] last_name
+      # @param [String] end_user_type
+      # return [EndUser] EndUser
+      def create(name, last_name = nil , end_user_type)
+        valid_param?(:name, name, [String, Symbol], true)
+        valid_param?(:last_name, last_name, [String, Symbol], false)
+        valid_param?(:end_user_type, end_user_type.capitalize, [String, Symbol], true, %w[Business Individual])
+
+        params = {
+          name: name,
+          last_name: last_name,
+          end_user_type: end_user_type.capitalize
+        }
+
+        return perform_create(params)
+      end
+
+      ##
+      # Update an EndUser
+      # @param [String] end_user_id
+      # @param [Hash] options
+      # return [EndUser]
+      def update(end_user_id, options = nil)
+        valid_param?(:end_user_id, end_user_id, [String, Symbol], true)
+        EndUser.new(@_client,
+                        resource_id: end_user_id).update(options)
+      end
+
+      ##
+      # Delete an EndUser.
+      # @param [String] end_user_id
+      def delete(end_user_id)
+        valid_param?(:end_user_id, end_user_id, [String, Symbol], true)
+        EndUser.new(@_client,
+                        resource_id: end_user_id).delete
+      end
+    end
+
+    class ComplianceDocumentType < Base::Resource
+      def initialize(client, options = nil)
+        @_name = 'ComplianceDocumentType'
+        @_identifier_string = 'compliance_document_type'
+        super
+      end
+
+      def to_s
+        {
+          api_id: @api_id,
+          document_type_id: @document_type_id,
+          document_name: @document_name,
+          description: @description,
+          information: @information,
+          proof_required: @proof_required,
+          created_at: @created_at
+        }.delete_if { |key, value| key==:api_id && value.nil? }.to_s
+      end
+    end
+
+    class ComplianceDocumentTypesInterface < Base::ResourceInterface
+      def initialize(client, resource_list_json = nil)
+        @_name = 'ComplianceDocumentType'
+        @_resource_type = ComplianceDocumentType
+        @_identifier_string = 'compliance_document_type'
+        super
+      end
+
+      # Get a ComplianceDocumentType
+      # @param [String] document_type_id
+      # @return [ComplianceDocumentType] ComplianceDocumentType
+      def get(document_type_id)
+        valid_param?(:document_type_id, document_type_id, [String, Symbol], true)
+        perform_get(document_type_id)
+      end
+
+      ##
+      # List all ComplianceDocumentTypes
+      # @option options [Int] :offset
+      # @option options [Int] :limit
+      # @return [Hash]
+      def list(options = nil)
+        return perform_list if options.nil?
+        valid_param?(:options, options, Hash, false)
+
+        params = {}
+        %i[offset limit].each do |param|
+          if options.key?(param) && valid_param?(param, options[param],
+                                                 [Integer], false)
+            params[param] = options[param]
+          end
+        end
+
+        raise_invalid_request("Offset can't be negative") if options.key?(:offset) && options[:offset] < 0
+
+        if options.key?(:limit) && (options[:limit] > 20 || options[:limit] <= 0)
+          raise_invalid_request('The maximum number of results that can be '\
+          "fetched is 20. limit can't be more than 20 or less than 1")
+        end
+
+        perform_list(params)
+      end
+    end
+
+    class ComplianceDocument < Base::Resource
+      def initialize(client, options = nil)
+        @_name = 'ComplianceDocument'
+        @_identifier_string = 'compliance_document'
+        super
+      end
+
+      def delete
+        perform_delete
+      end
+
+      def update(params)
+        perform_update(params, use_multipart_conn: true)
+      end
+
+      def to_s
+        {
+          api_id: @api_id,
+          end_user_id: @end_user_id,
+          document_type_id: @document_type_id,
+          compliance_document_id: @compliance_document_id,
+          document_id: @document_id,
+          alias: @alias,
+          meta_information: @meta_information,
+          file: @file,
+          file_name: @file_name,
+          created_at: @created_at
+        }.delete_if { |key, value| value.nil? }.to_s
+      end
+    end
+  
+    class ComplianceDocumentsInterface < Base::ResourceInterface 
+      def initialize(client, resource_list_json = nil)
+        @_name = 'ComplianceDocument'
+        @_resource_type = ComplianceDocument
+        @_identifier_string = 'compliance_document'
+        super
+      end
+
+      # Get a ComplianceDocument
+      # @param [String] compliance_document_id
+      # @return [ComplianceDocument] ComplianceDocument
+      def get(compliance_document_id)
+        valid_param?(:compliance_document_id, compliance_document_id, [String, Symbol], true)
+        perform_get(compliance_document_id)
+      end
+
+      # List all ComplianceDocuments
+      # @option options [Hash] :options
+      # @option options [Int] :offset
+      # @option options [Int] :limit
+      # @return [Hash]
+      def list(options = nil)
+        return perform_list if options.nil?
+        valid_param?(:options, options, Hash, false)
+
+        params = {}
+
+        params_expected = %i[ end_user_id document_type_id ]
+        params_expected.each do |param|
+          if options.key?(param) &&
+             valid_param?(param, options[param], [String, Symbol], false)
+            params[param] = options[param]
+          end
+        end
+
+        if options.key?(:alias) && valid_param?(:alias, options[:alias],[String, Symbol], false)
+          params[:alias] = options[:alias]
+        end
+
+        %i[offset limit].each do |param|
+          if options.key?(param) && valid_param?(param, options[param],
+                                                 [Integer], true)
+            params[param] = options[param]
+          end
+        end
+
+        raise_invalid_request("Offset can't be negative") if options.key?(:offset) && options[:offset] < 0
+
+        if options.key?(:limit) && (options[:limit] > 20 || options[:limit] <= 0)
+          raise_invalid_request('The maximum number of results that can be '\
+          "fetched is 20. limit can't be more than 20 or less than 1")
+        end
+
+        perform_list(params)
+      end
+
+      # Create a ComplianceDocument
+      # @param [String] end_user_id
+      # @param [String] document_type_id
+      # @param [String] alias_
+      # @param [String] file
+      # @param [Hash] options
+      # @return [ComplianceDocument] ComplianceDocument
+      def create(end_user_id: nil , document_type_id: nil, alias_: nil, file: nil, **options)
+        valid_param?(:end_user_id, end_user_id, [String, Symbol], true)
+        valid_param?(:document_type_id, document_type_id, [String, Symbol], true)
+        valid_param?(:alias, :alias_, [String, Symbol], true)
+
+        params = {
+          end_user_id: end_user_id,
+          document_type_id: document_type_id,
+          alias: alias_
+        }
+
+        if !options.nil?
+          valid_param?(:options, options, Hash, false) 
+          options.each do |key, value|
+            if valid_param?(key, value, [String, Symbol], false)
+              params[key] = value
+            end
+          end
+        end
+
+        upload(file, params) if !file.nil?
+
+        perform_create(params, use_multipart_conn: true)
+      end
+
+      # Update a ComplianceDocument
+      # @param [String] compliance_document_id
+      # @param [Hash] options
+      # return [ComplianceDocument] ComplianceDocument
+      def update(compliance_document_id, options = nil)
+        valid_param?(:compliance_document_id, compliance_document_id, [String, Symbol], true)
+        valid_param?(:options, options, Hash, true) if !options.nil?
+        params = {}
+
+        options.each do |key, value|
+          params[key] = value
+        end
+
+        upload(params[:file], params) if params.key?(:file)
+
+        ComplianceDocument.new(@_client, resource_id: compliance_document_id).update(params)
+      end
+
+      # Delete a ComplianceDocument
+      # @param [String] compliance_document_id
+      def delete(compliance_document_id)
+        valid_param?(:compliance_document_id, compliance_document_id, [String, Symbol], true)
+        ComplianceDocument.new(@_client, resource_id: compliance_document_id).delete
+      end
+
+      private
+
+      def upload(filepath, params)
+        file_extension = filepath.split('.')[-1]
+  
+        content_type = case file_extension
+                          when 'jpeg' then 'image/jpeg'
+                          when 'jpg' then 'image/jpeg'
+                          when 'png' then 'image/png'
+                          when 'pdf' then 'application/pdf'
+                          else raise_invalid_request("#{file_extension} is not supported for upload")
+                        end
+  
+        params[:file] = Faraday::UploadIO.new(filepath, content_type)
+      end
+    end
+
+    class ComplianceRequirement < Base::Resource
+      def initialize(client, options = nil)
+        @_name = 'ComplianceRequirement'
+        @_identifier_string = 'compliance_requirement'
+        super
+      end
+
+      def to_s
+        {
+          api_id: @api_id,
+          compliance_requirement_id: @compliance_requirement_id,
+          country_iso2: @country_iso2,
+          number_type: @number_type,
+          end_user_type: @end_user_type,
+          acceptable_document_types: @acceptable_document_types
+        }.delete_if { |key, value| value.nil? }.to_s
+      end
+    end
+  
+    class ComplianceRequirementsInterface < Base::ResourceInterface 
+      def initialize(client, resource_list_json = nil)
+        @_name = 'ComplianceRequirement'
+        @_resource_type = ComplianceRequirement
+        @_identifier_string = 'compliance_requirement'
+        super
+      end
+
+      # Get a ComplianceRequirement
+      # @param [String] compliance_requirement_id
+      # @return [ComplianceRequirement] ComplianceRequirement
+      def get(compliance_requirement_id)
+        valid_param?(:compliance_requirement_id, compliance_requirement_id, [String, Symbol], true)
+        perform_get(compliance_requirement_id)
+      end
+
+      # List all ComplianceRequirements
+      # @option options [String] :country_iso2
+      # @option options [String] :number_type
+      # @option options [String] :phone_number
+      # @option options [String] :end_user_type
+      # A combination of country_iso2, number_type, end_user_type OR
+      # phone_number, end_user_type can be used to fetch compliance requirements.
+      def list(options = nil)
+        valid_param?(:options, options, Hash, true)
+
+        params = {}
+        params_expected = %i[ country_iso2 number_type phone_number ]
+        params_expected.each do |param|
+          if options.key?(param) &&
+             valid_param?(param, options[param], [String, Symbol], false)
+            params[param] = options[param]
+          end
+        end
+
+        if options.key?(:end_user_type) &&
+          valid_param?(:end_user_type, options[:end_user_type].capitalize, [String, Symbol], false, %w[Business Individual])
+          params[:end_user_type] = options[:end_user_type].capitalize
+        end
+
+        perform_get_without_identifier(params)
+      end
+    end
+
+    class ComplianceApplication < Base::Resource
+      def initialize(client, options = nil)
+        @_name = 'ComplianceApplication'
+        @_identifier_string = 'compliance_application'
+        super
+      end
+
+      def to_s
+        {
+          api_id: @api_id,
+          created_at: @created_at,
+          compliance_application_id: @compliance_application_id,
+          alias: @alias,
+          status: @status,
+          end_user_id: @end_user_id,
+          end_user_type: @end_user_type,
+          country_iso2: @country_iso2,
+          number_type: @number_type,
+          compliance_requirement_id: @compliance_requirement_id,
+          documents: @documents,
+        }.delete_if { |key, value| value.nil? }.to_s
+      end
+
+      def update(params)
+        perform_update(params)
+      end
+
+      def delete
+        perform_delete
+      end
+    end
+  
+    class ComplianceApplicationsInterface < Base::ResourceInterface 
+      def initialize(client, resource_list_json = nil)
+        @_name = 'ComplianceApplication'
+        @_resource_type = ComplianceApplication
+        @_identifier_string = 'compliance_application'
+        super
+      end
+
+      # Get a ComplianceApplication
+      # @param [String] compliance_application_id
+      # @return [ComplianceApplication] ComplianceApplication
+      def get(compliance_application_id)
+        valid_param?(:compliance_application_id, compliance_application_id, [String, Symbol], true)
+        perform_get(compliance_application_id)
+      end
+
+      # List all ComplianceApplications
+      # @option options [Hash] :options
+      # @option options [Int] :offset
+      # @option options [Int] :limit
+      # @return [Hash]
+      def list(options = nil)
+        return perform_list if options.nil?
+        valid_param?(:options, options, Hash, true)
+
+        params = {}
+        params_expected = %i[  end_user_id country_iso2 number_type status ]
+        params_expected.each do |param|
+          if options.key?(param) &&
+             valid_param?(param, options[param], [String, Symbol], false)
+            params[param] = options[param]
+          end
+        end
+
+        if options.key?(:end_user_type) &&
+          valid_param?(:end_user_type, options[:end_user_type].capitalize, [String, Symbol], false, %w[Business Individual])
+          params[:end_user_type] = options[:end_user_type].capitalize
+        end
+
+        if options.key?(:alias) && valid_param?(:alias, options[:alias],[String, Symbol], false)
+          params[:alias] = options[:alias]
+        end
+
+        %i[offset limit].each do |param|
+          if options.key?(param) && valid_param?(param, options[param],
+                                                 [Integer], true)
+            params[param] = options[param]
+          end
+        end
+
+        raise_invalid_request("Offset can't be negative") if options.key?(:offset) && options[:offset] < 0
+
+        if options.key?(:limit) && (options[:limit] > 20 || options[:limit] <= 0)
+          raise_invalid_request('The maximum number of results that can be '\
+          "fetched is 20. limit can't be more than 20 or less than 1")
+        end
+
+        perform_list(params)
+      end
+
+      # Create a ComplianceApplication
+      # @param [String] compliance_requirement_id
+      # @param [String] end_user_id
+      # @param [String] alias_
+      # @param [Array] document_ids
+      # @param [String] end_user_type
+      # @param [String] country_iso2
+      # @param [String] number_type
+      # @return [ComplianceApplication] ComplianceApplication
+      def create(compliance_requirement_id: nil, end_user_id: nil, alias_: nil,
+        document_ids: nil,
+        end_user_type: nil,
+        country_iso2: nil,
+        number_type: nil
+        )
+        valid_param?(:compliance_requirement_id, compliance_requirement_id, [String, Symbol], false)
+        valid_param?(:end_user_id, end_user_id, [String, Symbol], false)
+        valid_param?(:alias_, alias_, [String, Symbol], false)
+        valid_param?(:country_iso2, country_iso2, [String, Symbol], false)
+        valid_param?(:number_type, number_type, [String, Symbol], false)
+        valid_param?(:document_ids, document_ids, [Array], false)
+        if !document_ids.nil?
+          document_ids.each do |document_id|
+            valid_param?(:document_id, document_id, [String, Symbol], true)
+          end
+        end
+
+        if !end_user_type.nil?
+          end_user_type = end_user_type.downcase
+          valid_param?(:end_user_type, end_user_type, [String, Symbol], false, %w[business individual])
+        end
+
+        params = {
+          compliance_requirement_id: compliance_requirement_id,
+          end_user_id: end_user_id,
+          end_user_type: end_user_type,
+          country_iso2: country_iso2,
+          number_type: number_type,
+          document_ids: document_ids,
+          alias: alias_
+        }.delete_if { |key, value| value.nil? }
+
+        perform_create(params, false)
+      end
+
+      # Update a ComplianceApplication
+      # @param [String] compliance_application_id
+      # @param [Array] document_ids
+      # @return [ComplianceApplication] ComplianceApplication
+      def update(compliance_application_id, document_ids)
+        valid_param?(:compliance_application_id, compliance_application_id, [String, Symbol], true)
+        valid_param?(:document_ids, document_ids, [Array], true)
+        document_ids.each do |document_id|
+          valid_param?(:document_id, document_id, [String, Symbol], true)
+        end
+
+        params = {
+          compliance_application_id: compliance_application_id,
+          document_ids: document_ids
+        }
+
+        ComplianceApplication.new(@_client,
+                        resource_id: compliance_application_id).update(params)
+      end
+
+      # Delete a ComplianceApplication
+      # @param [String] compliance_application_id
+      def delete(compliance_application_id)
+        valid_param?(:compliance_application_id, compliance_application_id, [String, Symbol], true)
+        ComplianceApplication.new(@_client,
+                        resource_id: compliance_application_id).delete
+      end
+
+      # Submit a ComplianceApplication
+      # @param [String] compliance_application_id
+      def submit(compliance_application_id)
+        valid_param?(:compliance_application_id, compliance_application_id, [String, Symbol], true)
+        perform_submit(compliance_application_id)
+      end
+    end
+  end
+end

data/lib/plivo/rest_client.rb

@@ -14,6 +14,8 @@ module Plivo
     attr_reader :powerpacks
     attr_reader :powerpacks, :media
     attr_reader :lookup
+    attr_reader :end_users
+    attr_reader :compliance_document_types, :compliance_documents, :compliance_requirements, :compliance_applications
 
     def initialize(auth_id = nil, auth_token = nil, proxy_options = nil, timeout = 5)
       configure_base_uri
@@ -50,6 +52,11 @@ module Plivo
       @identities = Resources::IdentityInterface.new(self)
       @call_feedback = Resources::CallFeedbackInterface.new(self)
       @lookup = Resources::LookupInterface.new(self)
+      @end_users = Resources::EndUsersInterface.new(self)
+      @compliance_document_types = Resources::ComplianceDocumentTypesInterface.new(self)
+      @compliance_documents = Resources::ComplianceDocumentsInterface.new(self)
+      @compliance_requirements = Resources::ComplianceRequirementsInterface.new(self)
+      @compliance_applications = Resources::ComplianceApplicationsInterface.new(self)
     end
   end
 end

data/lib/plivo/version.rb

@@ -1,3 +1,3 @@
 module Plivo
-  VERSION = "4.15.0".freeze
+  VERSION = "4.17.1".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plivo
 version: !ruby/object:Gem::Version
-  version: 4.15.0
+  version: 4.17.1
 platform: ruby
 authors:
 - The Plivo SDKs Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-11-17 00:00:00.000000000 Z
+date: 2021-07-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -168,6 +168,7 @@ files:
 - examples/lookup.rb
 - examples/multi_party_call.rb
 - examples/phlos.rb
+- examples/regulatory_compliance.rb
 - lib/plivo.rb
 - lib/plivo/base.rb
 - lib/plivo/base/resource.rb
@@ -196,6 +197,7 @@ files:
 - lib/plivo/resources/powerpacks.rb
 - lib/plivo/resources/pricings.rb
 - lib/plivo/resources/recordings.rb
+- lib/plivo/resources/regulatory_compliance.rb
 - lib/plivo/rest_client.rb
 - lib/plivo/utils.rb
 - lib/plivo/version.rb