twilio-ruby 7.10.7 → 7.11.2

data/lib/twilio-ruby/rest/conversations/v2.rb

@@ -31,104 +31,110 @@ module Twilio
 
                 ##
                 # @param [String] conversation_id 
-                # @return [Twilio::REST::Conversations::V2::ActionContext] if conversationId was passed.
+                # @param [String] action_id
+                # @return [Twilio::REST::Conversations::V2::ActionContext] if action_id was passed.
                 # @return [Twilio::REST::Conversations::V2::ActionList]
-                def actions(conversation_id=:unset)
+                def actions(conversation_id=:unset, action_id=:unset)
                     if conversation_id.nil?
                         raise ArgumentError, 'conversation_id cannot be nil'
                     end
+                    if action_id.nil?
+                        raise ArgumentError, 'action_id cannot be nil'
+                    end
 
-                    if conversation_id == :unset
+                    if conversation_id == :unset && action_id == :unset
                         @actions ||= ActionList.new self
+                    elsif conversation_id != :unset && action_id == :unset
+                        ActionList.new(self, conversation_id: conversation_id)
                     else
-                        ActionContext.new(self, conversation_id)
+                        ActionContext.new(self, conversation_id, action_id)
                     end
                 end
                 ##
-                # @param [String] conversation_sid 
-                # @param [String] sid
-                # @return [Twilio::REST::Conversations::V2::CommunicationContext] if sid was passed.
+                # @param [String] conversation_id 
+                # @param [String] id
+                # @return [Twilio::REST::Conversations::V2::CommunicationContext] if id was passed.
                 # @return [Twilio::REST::Conversations::V2::CommunicationList]
-                def communications(conversation_sid=:unset, sid=:unset)
-                    if conversation_sid.nil?
-                        raise ArgumentError, 'conversation_sid cannot be nil'
+                def communications(conversation_id=:unset, id=:unset)
+                    if conversation_id.nil?
+                        raise ArgumentError, 'conversation_id cannot be nil'
                     end
-                    if sid.nil?
-                        raise ArgumentError, 'sid cannot be nil'
+                    if id.nil?
+                        raise ArgumentError, 'id cannot be nil'
                     end
 
-                    if conversation_sid == :unset && sid == :unset
+                    if conversation_id == :unset && id == :unset
                         @communications ||= CommunicationList.new self
-                    elsif conversation_sid != :unset && sid == :unset
-                        CommunicationList.new(self, conversation_sid: conversation_sid)
+                    elsif conversation_id != :unset && id == :unset
+                        CommunicationList.new(self, conversation_id: conversation_id)
                     else
-                        CommunicationContext.new(self, conversation_sid, sid)
+                        CommunicationContext.new(self, conversation_id, id)
                     end
                 end
                 ##
-                # @param [String] sid 
-                # @return [Twilio::REST::Conversations::V2::ConfigurationContext] if sid was passed.
+                # @param [String] id 
+                # @return [Twilio::REST::Conversations::V2::ConfigurationContext] if id was passed.
                 # @return [Twilio::REST::Conversations::V2::ConfigurationList]
-                def configurations(sid=:unset)
-                    if sid.nil?
-                        raise ArgumentError, 'sid cannot be nil'
+                def configurations(id=:unset)
+                    if id.nil?
+                        raise ArgumentError, 'id cannot be nil'
                     end
 
-                    if sid == :unset
+                    if id == :unset
                         @configurations ||= ConfigurationList.new self
                     else
-                        ConfigurationContext.new(self, sid)
+                        ConfigurationContext.new(self, id)
                     end
                 end
                 ##
-                # @param [String] sid 
-                # @return [Twilio::REST::Conversations::V2::ConversationContext] if sid was passed.
+                # @param [String] id 
+                # @return [Twilio::REST::Conversations::V2::ConversationContext] if id was passed.
                 # @return [Twilio::REST::Conversations::V2::ConversationList]
-                def conversations(sid=:unset)
-                    if sid.nil?
-                        raise ArgumentError, 'sid cannot be nil'
+                def conversations(id=:unset)
+                    if id.nil?
+                        raise ArgumentError, 'id cannot be nil'
                     end
 
-                    if sid == :unset
+                    if id == :unset
                         @conversations ||= ConversationList.new self
                     else
-                        ConversationContext.new(self, sid)
+                        ConversationContext.new(self, id)
                     end
                 end
                 ##
-                # @param [String] sid 
-                # @return [Twilio::REST::Conversations::V2::OperationContext] if sid was passed.
+                # @param [String] id 
+                # @return [Twilio::REST::Conversations::V2::OperationContext] if id was passed.
                 # @return [Twilio::REST::Conversations::V2::OperationList]
-                def operations(sid=:unset)
-                    if sid.nil?
-                        raise ArgumentError, 'sid cannot be nil'
+                def operations(id=:unset)
+                    if id.nil?
+                        raise ArgumentError, 'id cannot be nil'
                     end
 
-                    if sid == :unset
+                    if id == :unset
                         @operations ||= OperationList.new self
                     else
-                        OperationContext.new(self, sid)
+                        OperationContext.new(self, id)
                     end
                 end
                 ##
-                # @param [String] conversation_sid 
-                # @param [String] sid
-                # @return [Twilio::REST::Conversations::V2::ParticipantContext] if sid was passed.
+                # @param [String] conversation_id 
+                # @param [String] id
+                # @return [Twilio::REST::Conversations::V2::ParticipantContext] if id was passed.
                 # @return [Twilio::REST::Conversations::V2::ParticipantList]
-                def participants(conversation_sid=:unset, sid=:unset)
-                    if conversation_sid.nil?
-                        raise ArgumentError, 'conversation_sid cannot be nil'
+                def participants(conversation_id=:unset, id=:unset)
+                    if conversation_id.nil?
+                        raise ArgumentError, 'conversation_id cannot be nil'
                     end
-                    if sid.nil?
-                        raise ArgumentError, 'sid cannot be nil'
+                    if id.nil?
+                        raise ArgumentError, 'id cannot be nil'
                     end
 
-                    if conversation_sid == :unset && sid == :unset
+                    if conversation_id == :unset && id == :unset
                         @participants ||= ParticipantList.new self
-                    elsif conversation_sid != :unset && sid == :unset
-                        ParticipantList.new(self, conversation_sid: conversation_sid)
+                    elsif conversation_id != :unset && id == :unset
+                        ParticipantList.new(self, conversation_id: conversation_id)
                     else
-                        ParticipantContext.new(self, conversation_sid, sid)
+                        ParticipantContext.new(self, conversation_id, id)
                     end
                 end
                 ##

data/lib/twilio-ruby/rest/events/v1/schema.rb

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

data/lib/twilio-ruby/rest/events/v1/sink/sink_test.rb

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

data/lib/twilio-ruby/rest/events/v1/sink/sink_validate.rb

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

data/lib/twilio-ruby/rest/flex_api/v1/assessments.rb

@@ -150,8 +150,8 @@ module Twilio
                     # Lists AssessmentsInstance records from the API as a list.
                     # Unlike stream(), this operation is eager and will load `limit` records into
                     # memory before returning.
-                    # @param [String] authorization The Authorization HTTP request header
                     # @param [String] segment_id The id of the segment.
+                    # @param [String] authorization The Authorization HTTP request header
                     # @param [Integer] limit Upper limit for the number of records to return. stream()
                     #    guarantees to never return more than limit.  Default is no limit
                     # @param [Integer] page_size Number of records to fetch per request, when
@@ -159,10 +159,10 @@ module Twilio
                     #    but a limit is defined, stream() will attempt to read the limit with the most
                     #    efficient page size, i.e. min(limit, 1000)
                     # @return [Array] Array of up to limit results
-                    def list(authorization: :unset, segment_id: :unset, limit: nil, page_size: nil)
+                    def list(segment_id: :unset, authorization: :unset, limit: nil, page_size: nil)
                         self.stream(
-                            authorization: authorization,
                             segment_id: segment_id,
+                            authorization: authorization,
                             limit: limit,
                             page_size: page_size
                         ).entries
@@ -172,8 +172,8 @@ module Twilio
                     # Streams Instance records from the API as an Enumerable.
                     # This operation lazily loads records as efficiently as possible until the limit
                     # is reached.
-                    # @param [String] authorization The Authorization HTTP request header
                     # @param [String] segment_id The id of the segment.
+                    # @param [String] authorization The Authorization HTTP request header
                     # @param [Integer] limit Upper limit for the number of records to return. stream()
                     #    guarantees to never return more than limit.  Default is no limit
                     # @param [Integer] page_size Number of records to fetch per request, when
@@ -181,12 +181,12 @@ module Twilio
                     #    but a limit is defined, stream() will attempt to read the limit with the most
                     #    efficient page size, i.e. min(limit, 1000)
                     # @return [Enumerable] Enumerable that will yield up to limit results
-                    def stream(authorization: :unset, segment_id: :unset, limit: nil, page_size: nil)
+                    def stream(segment_id: :unset, authorization: :unset, limit: nil, page_size: nil)
                         limits = @version.read_limits(limit, page_size)
 
                         page = self.page(
-                            authorization: authorization,
                             segment_id: segment_id,
+                            authorization: authorization,
                             page_size: limits[:page_size], )
 
                         return [].each if page.nil?
@@ -198,8 +198,8 @@ module Twilio
 
                     ##
                     # Lists AssessmentsPageMetadata records from the API as a list.
-                      # @param [String] authorization The Authorization HTTP request header
                       # @param [String] segment_id The id of the segment.
+                      # @param [String] authorization The Authorization HTTP request header
                     # @param [Integer] limit Upper limit for the number of records to return. stream()
                     #    guarantees to never return more than limit.  Default is no limit
                     # @param [Integer] page_size Number of records to fetch per request, when
@@ -207,15 +207,14 @@ module Twilio
                     #    but a limit is defined, stream() will attempt to read the limit with the most
                     #    efficient page size, i.e. min(limit, 1000)
                     # @return [Array] Array of up to limit results
-                    def list_with_metadata(authorization: :unset, segment_id: :unset, limit: nil, page_size: nil)
+                    def list_with_metadata(segment_id: :unset, authorization: :unset, limit: nil, page_size: nil)
                         limits = @version.read_limits(limit, page_size)
                         params = Twilio::Values.of({
-                            'Authorization' => authorization,
                             'SegmentId' => segment_id,
                             
                             'PageSize' => limits[:page_size],
                         });
-                        headers = Twilio::Values.of({})
+                        headers = Twilio::Values.of({ 'Authorization' => authorization,  })
 
                         response = @version.page('GET', @uri, params: params, headers: headers)
 
@@ -243,21 +242,20 @@ module Twilio
                     ##
                     # Retrieve a single page of AssessmentsInstance records from the API.
                     # Request is executed immediately.
-                    # @param [String] authorization The Authorization HTTP request header
                     # @param [String] segment_id The id of the segment.
+                    # @param [String] authorization The Authorization HTTP request header
                     # @param [String] page_token PageToken provided by the API
                     # @param [Integer] page_number Page Number, this value is simply for client state
                     # @param [Integer] page_size Number of records to return, defaults to 50
                     # @return [Page] Page of AssessmentsInstance
-                    def page(authorization: :unset, segment_id: :unset, page_token: :unset, page_number: :unset,page_size: :unset)
+                    def page(segment_id: :unset, authorization: :unset, page_token: :unset, page_number: :unset,page_size: :unset)
                         params = Twilio::Values.of({
-                            'Authorization' => authorization,
                             'SegmentId' => segment_id,
                             'PageToken' => page_token,
                             'Page' => page_number,
                             'PageSize' => page_size,
                         })
-                        headers = Twilio::Values.of({})
+                        headers = Twilio::Values.of({ 'Authorization' => authorization,  })
                         
                         
 

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

@@ -249,65 +249,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::FlexApi::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

data/lib/twilio-ruby/rest/flex_api/v1/insights_assessments_comment.rb

@@ -126,9 +126,9 @@ module Twilio
                     # Lists InsightsAssessmentsCommentInstance records from the API as a list.
                     # Unlike stream(), this operation is eager and will load `limit` records into
                     # memory before returning.
-                    # @param [String] authorization The Authorization HTTP request header
                     # @param [String] segment_id The id of the segment.
                     # @param [String] agent_id The id of the agent.
+                    # @param [String] authorization The Authorization HTTP request header
                     # @param [Integer] limit Upper limit for the number of records to return. stream()
                     #    guarantees to never return more than limit.  Default is no limit
                     # @param [Integer] page_size Number of records to fetch per request, when
@@ -136,11 +136,11 @@ module Twilio
                     #    but a limit is defined, stream() will attempt to read the limit with the most
                     #    efficient page size, i.e. min(limit, 1000)
                     # @return [Array] Array of up to limit results
-                    def list(authorization: :unset, segment_id: :unset, agent_id: :unset, limit: nil, page_size: nil)
+                    def list(segment_id: :unset, agent_id: :unset, authorization: :unset, limit: nil, page_size: nil)
                         self.stream(
-                            authorization: authorization,
                             segment_id: segment_id,
                             agent_id: agent_id,
+                            authorization: authorization,
                             limit: limit,
                             page_size: page_size
                         ).entries
@@ -150,9 +150,9 @@ module Twilio
                     # Streams Instance records from the API as an Enumerable.
                     # This operation lazily loads records as efficiently as possible until the limit
                     # is reached.
-                    # @param [String] authorization The Authorization HTTP request header
                     # @param [String] segment_id The id of the segment.
                     # @param [String] agent_id The id of the agent.
+                    # @param [String] authorization The Authorization HTTP request header
                     # @param [Integer] limit Upper limit for the number of records to return. stream()
                     #    guarantees to never return more than limit.  Default is no limit
                     # @param [Integer] page_size Number of records to fetch per request, when
@@ -160,13 +160,13 @@ module Twilio
                     #    but a limit is defined, stream() will attempt to read the limit with the most
                     #    efficient page size, i.e. min(limit, 1000)
                     # @return [Enumerable] Enumerable that will yield up to limit results
-                    def stream(authorization: :unset, segment_id: :unset, agent_id: :unset, limit: nil, page_size: nil)
+                    def stream(segment_id: :unset, agent_id: :unset, authorization: :unset, limit: nil, page_size: nil)
                         limits = @version.read_limits(limit, page_size)
 
                         page = self.page(
-                            authorization: authorization,
                             segment_id: segment_id,
                             agent_id: agent_id,
+                            authorization: authorization,
                             page_size: limits[:page_size], )
 
                         return [].each if page.nil?
@@ -178,9 +178,9 @@ module Twilio
 
                     ##
                     # Lists InsightsAssessmentsCommentPageMetadata records from the API as a list.
-                      # @param [String] authorization The Authorization HTTP request header
                       # @param [String] segment_id The id of the segment.
                       # @param [String] agent_id The id of the agent.
+                      # @param [String] authorization The Authorization HTTP request header
                     # @param [Integer] limit Upper limit for the number of records to return. stream()
                     #    guarantees to never return more than limit.  Default is no limit
                     # @param [Integer] page_size Number of records to fetch per request, when
@@ -188,16 +188,15 @@ module Twilio
                     #    but a limit is defined, stream() will attempt to read the limit with the most
                     #    efficient page size, i.e. min(limit, 1000)
                     # @return [Array] Array of up to limit results
-                    def list_with_metadata(authorization: :unset, segment_id: :unset, agent_id: :unset, limit: nil, page_size: nil)
+                    def list_with_metadata(segment_id: :unset, agent_id: :unset, authorization: :unset, limit: nil, page_size: nil)
                         limits = @version.read_limits(limit, page_size)
                         params = Twilio::Values.of({
-                            'Authorization' => authorization,
                             'SegmentId' => segment_id,
                             'AgentId' => agent_id,
                             
                             'PageSize' => limits[:page_size],
                         });
-                        headers = Twilio::Values.of({})
+                        headers = Twilio::Values.of({ 'Authorization' => authorization,  })
 
                         response = @version.page('GET', @uri, params: params, headers: headers)
 
@@ -225,23 +224,22 @@ module Twilio
                     ##
                     # Retrieve a single page of InsightsAssessmentsCommentInstance records from the API.
                     # Request is executed immediately.
-                    # @param [String] authorization The Authorization HTTP request header
                     # @param [String] segment_id The id of the segment.
                     # @param [String] agent_id The id of the agent.
+                    # @param [String] authorization The Authorization HTTP request header
                     # @param [String] page_token PageToken provided by the API
                     # @param [Integer] page_number Page Number, this value is simply for client state
                     # @param [Integer] page_size Number of records to return, defaults to 50
                     # @return [Page] Page of InsightsAssessmentsCommentInstance
-                    def page(authorization: :unset, segment_id: :unset, agent_id: :unset, page_token: :unset, page_number: :unset,page_size: :unset)
+                    def page(segment_id: :unset, agent_id: :unset, authorization: :unset, page_token: :unset, page_number: :unset,page_size: :unset)
                         params = Twilio::Values.of({
-                            'Authorization' => authorization,
                             'SegmentId' => segment_id,
                             'AgentId' => agent_id,
                             'PageToken' => page_token,
                             'Page' => page_number,
                             'PageSize' => page_size,
                         })
-                        headers = Twilio::Values.of({})
+                        headers = Twilio::Values.of({ 'Authorization' => authorization,  })