twilio-ruby 7.11.1 → 7.11.2

data/lib/twilio-ruby/rest/api/v2010/account/usage.rb

@@ -94,65 +94,6 @@ module Twilio
                     end
                 end
 
-                class UsagePageMetadata < PageMetadata
-                    attr_reader :usage_page
-
-                    def initialize(version, response, solution, limit)
-                        super(version, response)
-                        @usage_page = []
-                        @limit = limit
-                        key = get_key(response.body)
-                        records = 0
-                        while( limit != :unset && records < limit )
-                            @usage_page << UsageListResponse.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
-                        @usage_page.each do |record|
-                          yield record
-                        end
-                    end
-
-                    def to_s
-                      '<Twilio::REST::Api::V2010PageMetadata>';
-                    end
-                end
-                class UsageListResponse < InstanceListResource
-
-                    # @param [Array<UsageInstance>] 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
-                      @usage = data_list.map do |data|
-                        UsageInstance.new(version, data)
-                      end
-                      @headers = payload.headers
-                      @status_code = payload.status_code
-                    end
-
-                    def usage
-                        @usage
-                    end
-
-                    def headers
-                      @headers
-                    end
-
-                    def status_code
-                      @status_code
-                    end
-                end
-
                 class UsageInstance < InstanceResource
                     ##
                     # Initialize the UsageInstance

data/lib/twilio-ruby/rest/api/v2010/account/validation_request.rb

@@ -160,65 +160,6 @@ module Twilio
                     end
                 end
 
-                class ValidationRequestPageMetadata < PageMetadata
-                    attr_reader :validation_request_page
-
-                    def initialize(version, response, solution, limit)
-                        super(version, response)
-                        @validation_request_page = []
-                        @limit = limit
-                        key = get_key(response.body)
-                        records = 0
-                        while( limit != :unset && records < limit )
-                            @validation_request_page << ValidationRequestListResponse.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
-                        @validation_request_page.each do |record|
-                          yield record
-                        end
-                    end
-
-                    def to_s
-                      '<Twilio::REST::Api::V2010PageMetadata>';
-                    end
-                end
-                class ValidationRequestListResponse < InstanceListResource
-
-                    # @param [Array<ValidationRequestInstance>] 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
-                      @validation_request = data_list.map do |data|
-                        ValidationRequestInstance.new(version, data)
-                      end
-                      @headers = payload.headers
-                      @status_code = payload.status_code
-                    end
-
-                    def validation_request
-                        @validation_request
-                    end
-
-                    def headers
-                      @headers
-                    end
-
-                    def status_code
-                      @status_code
-                    end
-                end
-
                 class ValidationRequestInstance < InstanceResource
                     ##
                     # Initialize the ValidationRequestInstance

data/lib/twilio-ruby/rest/bulkexports/v1/export/job.rb

@@ -228,65 +228,6 @@ module Twilio
                     end
                 end
 
-                class JobPageMetadata < PageMetadata
-                    attr_reader :job_page
-
-                    def initialize(version, response, solution, limit)
-                        super(version, response)
-                        @job_page = []
-                        @limit = limit
-                        key = get_key(response.body)
-                        records = 0
-                        while( limit != :unset && records < limit )
-                            @job_page << JobListResponse.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
-                        @job_page.each do |record|
-                          yield record
-                        end
-                    end
-
-                    def to_s
-                      '<Twilio::REST::Bulkexports::V1PageMetadata>';
-                    end
-                end
-                class JobListResponse < InstanceListResource
-
-                    # @param [Array<JobInstance>] 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
-                      @job = data_list.map do |data|
-                        JobInstance.new(version, data)
-                      end
-                      @headers = payload.headers
-                      @status_code = payload.status_code
-                    end
-
-                    def job
-                        @job
-                    end
-
-                    def headers
-                      @headers
-                    end
-
-                    def status_code
-                      @status_code
-                    end
-                end
-
                 class JobInstance < InstanceResource
                     ##
                     # Initialize the JobInstance

data/lib/twilio-ruby/rest/bulkexports/v1/export.rb

@@ -240,65 +240,6 @@ module Twilio
                     end
                 end
 
-                class ExportPageMetadata < PageMetadata
-                    attr_reader :export_page
-
-                    def initialize(version, response, solution, limit)
-                        super(version, response)
-                        @export_page = []
-                        @limit = limit
-                        key = get_key(response.body)
-                        records = 0
-                        while( limit != :unset && records < limit )
-                            @export_page << ExportListResponse.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
-                        @export_page.each do |record|
-                          yield record
-                        end
-                    end
-
-                    def to_s
-                      '<Twilio::REST::Bulkexports::V1PageMetadata>';
-                    end
-                end
-                class ExportListResponse < InstanceListResource
-
-                    # @param [Array<ExportInstance>] 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
-                      @export = data_list.map do |data|
-                        ExportInstance.new(version, data)
-                      end
-                      @headers = payload.headers
-                      @status_code = payload.status_code
-                    end
-
-                    def export
-                        @export
-                    end
-
-                    def headers
-                      @headers
-                    end
-
-                    def status_code
-                      @status_code
-                    end
-                end
-
                 class ExportInstance < InstanceResource
                     ##
                     # Initialize the ExportInstance

data/lib/twilio-ruby/rest/bulkexports/v1/export_configuration.rb

@@ -264,65 +264,6 @@ module Twilio
                     end
                 end
 
-                class ExportConfigurationPageMetadata < PageMetadata
-                    attr_reader :export_configuration_page
-
-                    def initialize(version, response, solution, limit)
-                        super(version, response)
-                        @export_configuration_page = []
-                        @limit = limit
-                        key = get_key(response.body)
-                        records = 0
-                        while( limit != :unset && records < limit )
-                            @export_configuration_page << ExportConfigurationListResponse.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
-                        @export_configuration_page.each do |record|
-                          yield record
-                        end
-                    end
-
-                    def to_s
-                      '<Twilio::REST::Bulkexports::V1PageMetadata>';
-                    end
-                end
-                class ExportConfigurationListResponse < InstanceListResource
-
-                    # @param [Array<ExportConfigurationInstance>] 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
-                      @export_configuration = data_list.map do |data|
-                        ExportConfigurationInstance.new(version, data)
-                      end
-                      @headers = payload.headers
-                      @status_code = payload.status_code
-                    end
-
-                    def export_configuration
-                        @export_configuration
-                    end
-
-                    def headers
-                      @headers
-                    end
-
-                    def status_code
-                      @status_code
-                    end
-                end
-
                 class ExportConfigurationInstance < InstanceResource
                     ##
                     # Initialize the ExportConfigurationInstance

data/lib/twilio-ruby/rest/chat/v3/channel.rb

@@ -221,65 +221,6 @@ module Twilio
                     end
                 end
 
-                class ChannelPageMetadata < PageMetadata
-                    attr_reader :channel_page
-
-                    def initialize(version, response, solution, limit)
-                        super(version, response)
-                        @channel_page = []
-                        @limit = limit
-                        key = get_key(response.body)
-                        records = 0
-                        while( limit != :unset && records < limit )
-                            @channel_page << ChannelListResponse.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
-                        @channel_page.each do |record|
-                          yield record
-                        end
-                    end
-
-                    def to_s
-                      '<Twilio::REST::Chat::V3PageMetadata>';
-                    end
-                end
-                class ChannelListResponse < InstanceListResource
-
-                    # @param [Array<ChannelInstance>] 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
-                      @channel = data_list.map do |data|
-                        ChannelInstance.new(version, data)
-                      end
-                      @headers = payload.headers
-                      @status_code = payload.status_code
-                    end
-
-                    def channel
-                        @channel
-                    end
-
-                    def headers
-                      @headers
-                    end
-
-                    def status_code
-                      @status_code
-                    end
-                end
-
                 class ChannelInstance < InstanceResource
                     ##
                     # Initialize the ChannelInstance

data/lib/twilio-ruby/rest/content/v1/content/approval_create.rb

@@ -140,65 +140,6 @@ module Twilio
                     end
                 end
 
-                class ApprovalCreatePageMetadata < PageMetadata
-                    attr_reader :approval_create_page
-
-                    def initialize(version, response, solution, limit)
-                        super(version, response)
-                        @approval_create_page = []
-                        @limit = limit
-                        key = get_key(response.body)
-                        records = 0
-                        while( limit != :unset && records < limit )
-                            @approval_create_page << ApprovalCreateListResponse.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
-                        @approval_create_page.each do |record|
-                          yield record
-                        end
-                    end
-
-                    def to_s
-                      '<Twilio::REST::Content::V1PageMetadata>';
-                    end
-                end
-                class ApprovalCreateListResponse < InstanceListResource
-
-                    # @param [Array<ApprovalCreateInstance>] 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
-                      @approval_create = data_list.map do |data|
-                        ApprovalCreateInstance.new(version, data)
-                      end
-                      @headers = payload.headers
-                      @status_code = payload.status_code
-                    end
-
-                    def approval_create
-                        @approval_create
-                    end
-
-                    def headers
-                      @headers
-                    end
-
-                    def status_code
-                      @status_code
-                    end
-                end
-
                 class ApprovalCreateInstance < InstanceResource
                     ##
                     # Initialize the ApprovalCreateInstance

data/lib/twilio-ruby/rest/content/v1/content/approval_fetch.rb

@@ -196,65 +196,6 @@ module Twilio
                     end
                 end
 
-                class ApprovalFetchPageMetadata < PageMetadata
-                    attr_reader :approval_fetch_page
-
-                    def initialize(version, response, solution, limit)
-                        super(version, response)
-                        @approval_fetch_page = []
-                        @limit = limit
-                        key = get_key(response.body)
-                        records = 0
-                        while( limit != :unset && records < limit )
-                            @approval_fetch_page << ApprovalFetchListResponse.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
-                        @approval_fetch_page.each do |record|
-                          yield record
-                        end
-                    end
-
-                    def to_s
-                      '<Twilio::REST::Content::V1PageMetadata>';
-                    end
-                end
-                class ApprovalFetchListResponse < InstanceListResource
-
-                    # @param [Array<ApprovalFetchInstance>] 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
-                      @approval_fetch = data_list.map do |data|
-                        ApprovalFetchInstance.new(version, data)
-                      end
-                      @headers = payload.headers
-                      @status_code = payload.status_code
-                    end
-
-                    def approval_fetch
-                        @approval_fetch
-                    end
-
-                    def headers
-                      @headers
-                    end
-
-                    def status_code
-                      @status_code
-                    end
-                end
-
                 class ApprovalFetchInstance < InstanceResource
                     ##
                     # Initialize the ApprovalFetchInstance

data/lib/twilio-ruby/rest/conversations/v1/configuration/webhook.rb

@@ -273,65 +273,6 @@ module Twilio
                     end
                 end
 
-                class WebhookPageMetadata < PageMetadata
-                    attr_reader :webhook_page
-
-                    def initialize(version, response, solution, limit)
-                        super(version, response)
-                        @webhook_page = []
-                        @limit = limit
-                        key = get_key(response.body)
-                        records = 0
-                        while( limit != :unset && records < limit )
-                            @webhook_page << WebhookListResponse.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
-                        @webhook_page.each do |record|
-                          yield record
-                        end
-                    end
-
-                    def to_s
-                      '<Twilio::REST::Conversations::V1PageMetadata>';
-                    end
-                end
-                class WebhookListResponse < InstanceListResource
-
-                    # @param [Array<WebhookInstance>] 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
-                      @webhook = data_list.map do |data|
-                        WebhookInstance.new(version, data)
-                      end
-                      @headers = payload.headers
-                      @status_code = payload.status_code
-                    end
-
-                    def webhook
-                        @webhook
-                    end
-
-                    def headers
-                      @headers
-                    end
-
-                    def status_code
-                      @status_code
-                    end
-                end
-
                 class WebhookInstance < InstanceResource
                     ##
                     # Initialize the WebhookInstance

data/lib/twilio-ruby/rest/conversations/v1/configuration.rb

@@ -275,65 +275,6 @@ module Twilio
                     end
                 end
 
-                class ConfigurationPageMetadata < PageMetadata
-                    attr_reader :configuration_page
-
-                    def initialize(version, response, solution, limit)
-                        super(version, response)
-                        @configuration_page = []
-                        @limit = limit
-                        key = get_key(response.body)
-                        records = 0
-                        while( limit != :unset && records < limit )
-                            @configuration_page << ConfigurationListResponse.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
-                        @configuration_page.each do |record|
-                          yield record
-                        end
-                    end
-
-                    def to_s
-                      '<Twilio::REST::Conversations::V1PageMetadata>';
-                    end
-                end
-                class ConfigurationListResponse < InstanceListResource
-
-                    # @param [Array<ConfigurationInstance>] 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
-                      @configuration = data_list.map do |data|
-                        ConfigurationInstance.new(version, data)
-                      end
-                      @headers = payload.headers
-                      @status_code = payload.status_code
-                    end
-
-                    def configuration
-                        @configuration
-                    end
-
-                    def headers
-                      @headers
-                    end
-
-                    def status_code
-                      @status_code
-                    end
-                end
-
                 class ConfigurationInstance < InstanceResource
                     ##
                     # Initialize the ConfigurationInstance