twilio-ruby 7.11.1 → 7.11.2

data/lib/twilio-ruby/rest/messaging/v1/request_managed_cert.rb

@@ -194,65 +194,6 @@ module Twilio
                     end
                 end
 
-                class RequestManagedCertPageMetadata < PageMetadata
-                    attr_reader :request_managed_cert_page
-
-                    def initialize(version, response, solution, limit)
-                        super(version, response)
-                        @request_managed_cert_page = []
-                        @limit = limit
-                        key = get_key(response.body)
-                        records = 0
-                        while( limit != :unset && records < limit )
-                            @request_managed_cert_page << RequestManagedCertListResponse.new(version, @payload, key, limit - records)
-                            @payload = self.next_page
-                            break unless @payload
-                            records += (@payload.body[key] || []).size
-                        end
-                        # Path Solution
-                        @solution = solution
-                    end
-
-                    def each
-                        @request_managed_cert_page.each do |record|
-                          yield record
-                        end
-                    end
-
-                    def to_s
-                      '<Twilio::REST::Messaging::V1PageMetadata>';
-                    end
-                end
-                class RequestManagedCertListResponse < InstanceListResource
-
-                    # @param [Array<RequestManagedCertInstance>] instance
-                    # @param [Hash{String => Object}] headers
-                    # @param [Integer] status_code
-                    def initialize(version, payload, key, limit = :unset)
-                      data_list = payload.body[key]  || []
-                      if limit != :unset
-                        data_list = data_list[0, limit]
-                      end
-                      @request_managed_cert = data_list.map do |data|
-                        RequestManagedCertInstance.new(version, data)
-                      end
-                      @headers = payload.headers
-                      @status_code = payload.status_code
-                    end
-
-                    def request_managed_cert
-                        @request_managed_cert
-                    end
-
-                    def headers
-                      @headers
-                    end
-
-                    def status_code
-                      @status_code
-                    end
-                end
-
                 class RequestManagedCertInstance < InstanceResource
                     ##
                     # Initialize the RequestManagedCertInstance

data/lib/twilio-ruby/rest/messaging/v1/service/us_app_to_person.rb

@@ -257,11 +257,10 @@ module Twilio
                     def list_with_metadata(x_twilio_api_version: :unset, limit: nil, page_size: nil)
                         limits = @version.read_limits(limit, page_size)
                         params = Twilio::Values.of({
-                            'X-Twilio-Api-Version' => x_twilio_api_version,
                             
                             'PageSize' => limits[:page_size],
                         });
-                        headers = Twilio::Values.of({})
+                        headers = Twilio::Values.of({ 'X-Twilio-Api-Version' => x_twilio_api_version,  })
 
                         response = @version.page('GET', @uri, params: params, headers: headers)
 
@@ -296,12 +295,11 @@ module Twilio
                     # @return [Page] Page of UsAppToPersonInstance
                     def page(x_twilio_api_version: :unset, page_token: :unset, page_number: :unset,page_size: :unset)
                         params = Twilio::Values.of({
-                            'X-Twilio-Api-Version' => x_twilio_api_version,
                             'PageToken' => page_token,
                             'Page' => page_number,
                             'PageSize' => page_size,
                         })
-                        headers = Twilio::Values.of({})
+                        headers = Twilio::Values.of({ 'X-Twilio-Api-Version' => x_twilio_api_version,  })
                         
                         
 

data/lib/twilio-ruby/rest/messaging/v1/service/us_app_to_person_usecase.rb

@@ -128,65 +128,6 @@ module Twilio
                     end
                 end
 
-                class UsAppToPersonUsecasePageMetadata < PageMetadata
-                    attr_reader :us_app_to_person_usecase_page
-
-                    def initialize(version, response, solution, limit)
-                        super(version, response)
-                        @us_app_to_person_usecase_page = []
-                        @limit = limit
-                        key = get_key(response.body)
-                        records = 0
-                        while( limit != :unset && records < limit )
-                            @us_app_to_person_usecase_page << UsAppToPersonUsecaseListResponse.new(version, @payload, key, limit - records)
-                            @payload = self.next_page
-                            break unless @payload
-                            records += (@payload.body[key] || []).size
-                        end
-                        # Path Solution
-                        @solution = solution
-                    end
-
-                    def each
-                        @us_app_to_person_usecase_page.each do |record|
-                          yield record
-                        end
-                    end
-
-                    def to_s
-                      '<Twilio::REST::Messaging::V1PageMetadata>';
-                    end
-                end
-                class UsAppToPersonUsecaseListResponse < InstanceListResource
-
-                    # @param [Array<UsAppToPersonUsecaseInstance>] instance
-                    # @param [Hash{String => Object}] headers
-                    # @param [Integer] status_code
-                    def initialize(version, payload, key, limit = :unset)
-                      data_list = payload.body[key]  || []
-                      if limit != :unset
-                        data_list = data_list[0, limit]
-                      end
-                      @us_app_to_person_usecase = data_list.map do |data|
-                        UsAppToPersonUsecaseInstance.new(version, data)
-                      end
-                      @headers = payload.headers
-                      @status_code = payload.status_code
-                    end
-
-                    def us_app_to_person_usecase
-                        @us_app_to_person_usecase
-                    end
-
-                    def headers
-                      @headers
-                    end
-
-                    def status_code
-                      @status_code
-                    end
-                end
-
                 class UsAppToPersonUsecaseInstance < InstanceResource
                     ##
                     # Initialize the UsAppToPersonUsecaseInstance

data/lib/twilio-ruby/rest/messaging/v1/usecase.rb

@@ -112,65 +112,6 @@ module Twilio
                     end
                 end
 
-                class UsecasePageMetadata < PageMetadata
-                    attr_reader :usecase_page
-
-                    def initialize(version, response, solution, limit)
-                        super(version, response)
-                        @usecase_page = []
-                        @limit = limit
-                        key = get_key(response.body)
-                        records = 0
-                        while( limit != :unset && records < limit )
-                            @usecase_page << UsecaseListResponse.new(version, @payload, key, limit - records)
-                            @payload = self.next_page
-                            break unless @payload
-                            records += (@payload.body[key] || []).size
-                        end
-                        # Path Solution
-                        @solution = solution
-                    end
-
-                    def each
-                        @usecase_page.each do |record|
-                          yield record
-                        end
-                    end
-
-                    def to_s
-                      '<Twilio::REST::Messaging::V1PageMetadata>';
-                    end
-                end
-                class UsecaseListResponse < InstanceListResource
-
-                    # @param [Array<UsecaseInstance>] instance
-                    # @param [Hash{String => Object}] headers
-                    # @param [Integer] status_code
-                    def initialize(version, payload, key, limit = :unset)
-                      data_list = payload.body[key]  || []
-                      if limit != :unset
-                        data_list = data_list[0, limit]
-                      end
-                      @usecase = data_list.map do |data|
-                        UsecaseInstance.new(version, data)
-                      end
-                      @headers = payload.headers
-                      @status_code = payload.status_code
-                    end
-
-                    def usecase
-                        @usecase
-                    end
-
-                    def headers
-                      @headers
-                    end
-
-                    def status_code
-                      @status_code
-                    end
-                end
-
                 class UsecaseInstance < InstanceResource
                     ##
                     # Initialize the UsecaseInstance

data/lib/twilio-ruby/rest/messaging/v2/domain_certs.rb

@@ -194,65 +194,6 @@ module Twilio
                     end
                 end
 
-                class DomainCertsPageMetadata < PageMetadata
-                    attr_reader :domain_certs_page
-
-                    def initialize(version, response, solution, limit)
-                        super(version, response)
-                        @domain_certs_page = []
-                        @limit = limit
-                        key = get_key(response.body)
-                        records = 0
-                        while( limit != :unset && records < limit )
-                            @domain_certs_page << DomainCertsListResponse.new(version, @payload, key, limit - records)
-                            @payload = self.next_page
-                            break unless @payload
-                            records += (@payload.body[key] || []).size
-                        end
-                        # Path Solution
-                        @solution = solution
-                    end
-
-                    def each
-                        @domain_certs_page.each do |record|
-                          yield record
-                        end
-                    end
-
-                    def to_s
-                      '<Twilio::REST::Messaging::V2PageMetadata>';
-                    end
-                end
-                class DomainCertsListResponse < InstanceListResource
-
-                    # @param [Array<DomainCertsInstance>] instance
-                    # @param [Hash{String => Object}] headers
-                    # @param [Integer] status_code
-                    def initialize(version, payload, key, limit = :unset)
-                      data_list = payload.body[key]  || []
-                      if limit != :unset
-                        data_list = data_list[0, limit]
-                      end
-                      @domain_certs = data_list.map do |data|
-                        DomainCertsInstance.new(version, data)
-                      end
-                      @headers = payload.headers
-                      @status_code = payload.status_code
-                    end
-
-                    def domain_certs
-                        @domain_certs
-                    end
-
-                    def headers
-                      @headers
-                    end
-
-                    def status_code
-                      @status_code
-                    end
-                end
-
                 class DomainCertsInstance < InstanceResource
                     ##
                     # Initialize the DomainCertsInstance

data/lib/twilio-ruby/rest/messaging/v2/typing_indicator.rb

@@ -132,65 +132,6 @@ module Twilio
                     end
                 end
 
-                class TypingIndicatorPageMetadata < PageMetadata
-                    attr_reader :typing_indicator_page
-
-                    def initialize(version, response, solution, limit)
-                        super(version, response)
-                        @typing_indicator_page = []
-                        @limit = limit
-                        key = get_key(response.body)
-                        records = 0
-                        while( limit != :unset && records < limit )
-                            @typing_indicator_page << TypingIndicatorListResponse.new(version, @payload, key, limit - records)
-                            @payload = self.next_page
-                            break unless @payload
-                            records += (@payload.body[key] || []).size
-                        end
-                        # Path Solution
-                        @solution = solution
-                    end
-
-                    def each
-                        @typing_indicator_page.each do |record|
-                          yield record
-                        end
-                    end
-
-                    def to_s
-                      '<Twilio::REST::Messaging::V2PageMetadata>';
-                    end
-                end
-                class TypingIndicatorListResponse < InstanceListResource
-
-                    # @param [Array<TypingIndicatorInstance>] instance
-                    # @param [Hash{String => Object}] headers
-                    # @param [Integer] status_code
-                    def initialize(version, payload, key, limit = :unset)
-                      data_list = payload.body[key]  || []
-                      if limit != :unset
-                        data_list = data_list[0, limit]
-                      end
-                      @typing_indicator = data_list.map do |data|
-                        TypingIndicatorInstance.new(version, data)
-                      end
-                      @headers = payload.headers
-                      @status_code = payload.status_code
-                    end
-
-                    def typing_indicator
-                        @typing_indicator
-                    end
-
-                    def headers
-                      @headers
-                    end
-
-                    def status_code
-                      @status_code
-                    end
-                end
-
                 class TypingIndicatorInstance < InstanceResource
                     ##
                     # Initialize the TypingIndicatorInstance

data/lib/twilio-ruby/rest/messaging/v3/typing_indicator.rb

@@ -142,65 +142,6 @@ module Twilio
                     end
                 end
 
-                class TypingIndicatorPageMetadata < PageMetadata
-                    attr_reader :typing_indicator_page
-
-                    def initialize(version, response, solution, limit)
-                        super(version, response)
-                        @typing_indicator_page = []
-                        @limit = limit
-                        key = get_key(response.body)
-                        records = 0
-                        while( limit != :unset && records < limit )
-                            @typing_indicator_page << TypingIndicatorListResponse.new(version, @payload, key, limit - records)
-                            @payload = self.next_page
-                            break unless @payload
-                            records += (@payload.body[key] || []).size
-                        end
-                        # Path Solution
-                        @solution = solution
-                    end
-
-                    def each
-                        @typing_indicator_page.each do |record|
-                          yield record
-                        end
-                    end
-
-                    def to_s
-                      '<Twilio::REST::Messaging::V3PageMetadata>';
-                    end
-                end
-                class TypingIndicatorListResponse < InstanceListResource
-
-                    # @param [Array<TypingIndicatorInstance>] instance
-                    # @param [Hash{String => Object}] headers
-                    # @param [Integer] status_code
-                    def initialize(version, payload, key, limit = :unset)
-                      data_list = payload.body[key]  || []
-                      if limit != :unset
-                        data_list = data_list[0, limit]
-                      end
-                      @typing_indicator = data_list.map do |data|
-                        TypingIndicatorInstance.new(version, data)
-                      end
-                      @headers = payload.headers
-                      @status_code = payload.status_code
-                    end
-
-                    def typing_indicator
-                        @typing_indicator
-                    end
-
-                    def headers
-                      @headers
-                    end
-
-                    def status_code
-                      @status_code
-                    end
-                end
-
                 class TypingIndicatorInstance < InstanceResource
                     ##
                     # Initialize the TypingIndicatorInstance

data/lib/twilio-ruby/rest/notify/v1/service/notification.rb

@@ -232,65 +232,6 @@ module Twilio
                     end
                 end
 
-                class NotificationPageMetadata < PageMetadata
-                    attr_reader :notification_page
-
-                    def initialize(version, response, solution, limit)
-                        super(version, response)
-                        @notification_page = []
-                        @limit = limit
-                        key = get_key(response.body)
-                        records = 0
-                        while( limit != :unset && records < limit )
-                            @notification_page << NotificationListResponse.new(version, @payload, key, limit - records)
-                            @payload = self.next_page
-                            break unless @payload
-                            records += (@payload.body[key] || []).size
-                        end
-                        # Path Solution
-                        @solution = solution
-                    end
-
-                    def each
-                        @notification_page.each do |record|
-                          yield record
-                        end
-                    end
-
-                    def to_s
-                      '<Twilio::REST::Notify::V1PageMetadata>';
-                    end
-                end
-                class NotificationListResponse < InstanceListResource
-
-                    # @param [Array<NotificationInstance>] instance
-                    # @param [Hash{String => Object}] headers
-                    # @param [Integer] status_code
-                    def initialize(version, payload, key, limit = :unset)
-                      data_list = payload.body[key]  || []
-                      if limit != :unset
-                        data_list = data_list[0, limit]
-                      end
-                      @notification = data_list.map do |data|
-                        NotificationInstance.new(version, data)
-                      end
-                      @headers = payload.headers
-                      @status_code = payload.status_code
-                    end
-
-                    def notification
-                        @notification
-                    end
-
-                    def headers
-                      @headers
-                    end
-
-                    def status_code
-                      @status_code
-                    end
-                end
-
                 class NotificationInstance < InstanceResource
                     ##
                     # Initialize the NotificationInstance

data/lib/twilio-ruby/rest/numbers/v1/bulk_eligibility.rb

@@ -240,65 +240,6 @@ module Twilio
                     end
                 end
 
-                class BulkEligibilityPageMetadata < PageMetadata
-                    attr_reader :bulk_eligibility_page
-
-                    def initialize(version, response, solution, limit)
-                        super(version, response)
-                        @bulk_eligibility_page = []
-                        @limit = limit
-                        key = get_key(response.body)
-                        records = 0
-                        while( limit != :unset && records < limit )
-                            @bulk_eligibility_page << BulkEligibilityListResponse.new(version, @payload, key, limit - records)
-                            @payload = self.next_page
-                            break unless @payload
-                            records += (@payload.body[key] || []).size
-                        end
-                        # Path Solution
-                        @solution = solution
-                    end
-
-                    def each
-                        @bulk_eligibility_page.each do |record|
-                          yield record
-                        end
-                    end
-
-                    def to_s
-                      '<Twilio::REST::Numbers::V1PageMetadata>';
-                    end
-                end
-                class BulkEligibilityListResponse < InstanceListResource
-
-                    # @param [Array<BulkEligibilityInstance>] instance
-                    # @param [Hash{String => Object}] headers
-                    # @param [Integer] status_code
-                    def initialize(version, payload, key, limit = :unset)
-                      data_list = payload.body[key]  || []
-                      if limit != :unset
-                        data_list = data_list[0, limit]
-                      end
-                      @bulk_eligibility = data_list.map do |data|
-                        BulkEligibilityInstance.new(version, data)
-                      end
-                      @headers = payload.headers
-                      @status_code = payload.status_code
-                    end
-
-                    def bulk_eligibility
-                        @bulk_eligibility
-                    end
-
-                    def headers
-                      @headers
-                    end
-
-                    def status_code
-                      @status_code
-                    end
-                end
-
                 class BulkEligibilityInstance < InstanceResource
                     ##
                     # Initialize the BulkEligibilityInstance

data/lib/twilio-ruby/rest/numbers/v1/eligibility.rb

@@ -116,65 +116,6 @@ module Twilio
                     end
                 end
 
-                class EligibilityPageMetadata < PageMetadata
-                    attr_reader :eligibility_page
-
-                    def initialize(version, response, solution, limit)
-                        super(version, response)
-                        @eligibility_page = []
-                        @limit = limit
-                        key = get_key(response.body)
-                        records = 0
-                        while( limit != :unset && records < limit )
-                            @eligibility_page << EligibilityListResponse.new(version, @payload, key, limit - records)
-                            @payload = self.next_page
-                            break unless @payload
-                            records += (@payload.body[key] || []).size
-                        end
-                        # Path Solution
-                        @solution = solution
-                    end
-
-                    def each
-                        @eligibility_page.each do |record|
-                          yield record
-                        end
-                    end
-
-                    def to_s
-                      '<Twilio::REST::Numbers::V1PageMetadata>';
-                    end
-                end
-                class EligibilityListResponse < InstanceListResource
-
-                    # @param [Array<EligibilityInstance>] instance
-                    # @param [Hash{String => Object}] headers
-                    # @param [Integer] status_code
-                    def initialize(version, payload, key, limit = :unset)
-                      data_list = payload.body[key]  || []
-                      if limit != :unset
-                        data_list = data_list[0, limit]
-                      end
-                      @eligibility = data_list.map do |data|
-                        EligibilityInstance.new(version, data)
-                      end
-                      @headers = payload.headers
-                      @status_code = payload.status_code
-                    end
-
-                    def eligibility
-                        @eligibility
-                    end
-
-                    def headers
-                      @headers
-                    end
-
-                    def status_code
-                      @status_code
-                    end
-                end
-
                 class EligibilityInstance < InstanceResource
                     ##
                     # Initialize the EligibilityInstance