twilio-ruby 7.11.1 → 7.11.2

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

@@ -114,8 +114,8 @@ module Twilio
                     # Lists InsightsQuestionnairesInstance 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 [Boolean] include_inactive Flag indicating whether to include inactive questionnaires or not
+                    # @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
@@ -123,10 +123,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, include_inactive: :unset, limit: nil, page_size: nil)
+                    def list(include_inactive: :unset, authorization: :unset, limit: nil, page_size: nil)
                         self.stream(
-                            authorization: authorization,
                             include_inactive: include_inactive,
+                            authorization: authorization,
                             limit: limit,
                             page_size: page_size
                         ).entries
@@ -136,8 +136,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 [Boolean] include_inactive Flag indicating whether to include inactive questionnaires or not
+                    # @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
@@ -145,12 +145,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, include_inactive: :unset, limit: nil, page_size: nil)
+                    def stream(include_inactive: :unset, authorization: :unset, limit: nil, page_size: nil)
                         limits = @version.read_limits(limit, page_size)
 
                         page = self.page(
-                            authorization: authorization,
                             include_inactive: include_inactive,
+                            authorization: authorization,
                             page_size: limits[:page_size], )
 
                         return [].each if page.nil?
@@ -162,8 +162,8 @@ module Twilio
 
                     ##
                     # Lists InsightsQuestionnairesPageMetadata records from the API as a list.
-                      # @param [String] authorization The Authorization HTTP request header
                       # @param [Boolean] include_inactive Flag indicating whether to include inactive questionnaires or not
+                      # @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
@@ -171,15 +171,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, include_inactive: :unset, limit: nil, page_size: nil)
+                    def list_with_metadata(include_inactive: :unset, authorization: :unset, limit: nil, page_size: nil)
                         limits = @version.read_limits(limit, page_size)
                         params = Twilio::Values.of({
-                            'Authorization' => authorization,
                             'IncludeInactive' => include_inactive,
                             
                             'PageSize' => limits[:page_size],
                         });
-                        headers = Twilio::Values.of({})
+                        headers = Twilio::Values.of({ 'Authorization' => authorization,  })
 
                         response = @version.page('GET', @uri, params: params, headers: headers)
 
@@ -207,21 +206,20 @@ module Twilio
                     ##
                     # Retrieve a single page of InsightsQuestionnairesInstance records from the API.
                     # Request is executed immediately.
-                    # @param [String] authorization The Authorization HTTP request header
                     # @param [Boolean] include_inactive Flag indicating whether to include inactive questionnaires or not
+                    # @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 InsightsQuestionnairesInstance
-                    def page(authorization: :unset, include_inactive: :unset, page_token: :unset, page_number: :unset,page_size: :unset)
+                    def page(include_inactive: :unset, authorization: :unset, page_token: :unset, page_number: :unset,page_size: :unset)
                         params = Twilio::Values.of({
-                            'Authorization' => authorization,
                             'IncludeInactive' => include_inactive,
                             '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/insights_questionnaires_category.rb

@@ -151,11 +151,10 @@ module Twilio
                     def list_with_metadata(authorization: :unset, limit: nil, page_size: nil)
                         limits = @version.read_limits(limit, page_size)
                         params = Twilio::Values.of({
-                            'Authorization' => authorization,
                             
                             'PageSize' => limits[:page_size],
                         });
-                        headers = Twilio::Values.of({})
+                        headers = Twilio::Values.of({ 'Authorization' => authorization,  })
 
                         response = @version.page('GET', @uri, params: params, headers: headers)
 
@@ -190,12 +189,11 @@ module Twilio
                     # @return [Page] Page of InsightsQuestionnairesCategoryInstance
                     def page(authorization: :unset, page_token: :unset, page_number: :unset,page_size: :unset)
                         params = Twilio::Values.of({
-                            'Authorization' => authorization,
                             '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/insights_questionnaires_question.rb

@@ -120,8 +120,8 @@ module Twilio
                     # Lists InsightsQuestionnairesQuestionInstance 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 [Array[String]] category_sid The list of category SIDs
+                    # @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
@@ -129,10 +129,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, category_sid: :unset, limit: nil, page_size: nil)
+                    def list(category_sid: :unset, authorization: :unset, limit: nil, page_size: nil)
                         self.stream(
-                            authorization: authorization,
                             category_sid: category_sid,
+                            authorization: authorization,
                             limit: limit,
                             page_size: page_size
                         ).entries
@@ -142,8 +142,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 [Array[String]] category_sid The list of category SIDs
+                    # @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
@@ -151,12 +151,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, category_sid: :unset, limit: nil, page_size: nil)
+                    def stream(category_sid: :unset, authorization: :unset, limit: nil, page_size: nil)
                         limits = @version.read_limits(limit, page_size)
 
                         page = self.page(
-                            authorization: authorization,
                             category_sid: category_sid,
+                            authorization: authorization,
                             page_size: limits[:page_size], )
 
                         return [].each if page.nil?
@@ -168,8 +168,8 @@ module Twilio
 
                     ##
                     # Lists InsightsQuestionnairesQuestionPageMetadata records from the API as a list.
-                      # @param [String] authorization The Authorization HTTP request header
                       # @param [Array[String]] category_sid The list of category SIDs
+                      # @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
@@ -177,16 +177,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, category_sid: :unset, limit: nil, page_size: nil)
+                    def list_with_metadata(category_sid: :unset, authorization: :unset, limit: nil, page_size: nil)
                         limits = @version.read_limits(limit, page_size)
                         params = Twilio::Values.of({
-                            'Authorization' => authorization,
                             
                             'CategorySid' =>  Twilio.serialize_list(category_sid) { |e| e },
                             
                             'PageSize' => limits[:page_size],
                         });
-                        headers = Twilio::Values.of({})
+                        headers = Twilio::Values.of({ 'Authorization' => authorization,  })
 
                         response = @version.page('GET', @uri, params: params, headers: headers)
 
@@ -214,22 +213,21 @@ module Twilio
                     ##
                     # Retrieve a single page of InsightsQuestionnairesQuestionInstance records from the API.
                     # Request is executed immediately.
-                    # @param [String] authorization The Authorization HTTP request header
                     # @param [Array[String]] category_sid The list of category SIDs
+                    # @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 InsightsQuestionnairesQuestionInstance
-                    def page(authorization: :unset, category_sid: :unset, page_token: :unset, page_number: :unset,page_size: :unset)
+                    def page(category_sid: :unset, authorization: :unset, page_token: :unset, page_number: :unset,page_size: :unset)
                         params = Twilio::Values.of({
-                            'Authorization' => authorization,
                             
                             'CategorySid' =>  Twilio.serialize_list(category_sid) { |e| e },
                             '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/insights_segments.rb

@@ -36,9 +36,9 @@ module Twilio
                     # Lists InsightsSegmentsInstance 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 To unique id of the segment
                     # @param [Array[String]] reservation_id The list of reservation Ids
+                    # @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
@@ -46,11 +46,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, reservation_id: :unset, limit: nil, page_size: nil)
+                    def list(segment_id: :unset, reservation_id: :unset, authorization: :unset, limit: nil, page_size: nil)
                         self.stream(
-                            authorization: authorization,
                             segment_id: segment_id,
                             reservation_id: reservation_id,
+                            authorization: authorization,
                             limit: limit,
                             page_size: page_size
                         ).entries
@@ -60,9 +60,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 To unique id of the segment
                     # @param [Array[String]] reservation_id The list of reservation Ids
+                    # @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
@@ -70,13 +70,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, reservation_id: :unset, limit: nil, page_size: nil)
+                    def stream(segment_id: :unset, reservation_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,
                             reservation_id: reservation_id,
+                            authorization: authorization,
                             page_size: limits[:page_size], )
 
                         return [].each if page.nil?
@@ -88,9 +88,9 @@ module Twilio
 
                     ##
                     # Lists InsightsSegmentsPageMetadata records from the API as a list.
-                      # @param [String] authorization The Authorization HTTP request header
                       # @param [String] segment_id To unique id of the segment
                       # @param [Array[String]] reservation_id The list of reservation Ids
+                      # @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
@@ -98,17 +98,16 @@ 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, reservation_id: :unset, limit: nil, page_size: nil)
+                    def list_with_metadata(segment_id: :unset, reservation_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,
                             
                             'ReservationId' =>  Twilio.serialize_list(reservation_id) { |e| e },
                             
                             'PageSize' => limits[:page_size],
                         });
-                        headers = Twilio::Values.of({})
+                        headers = Twilio::Values.of({ 'Authorization' => authorization,  })
 
                         response = @version.page('GET', @uri, params: params, headers: headers)
 
@@ -136,16 +135,15 @@ module Twilio
                     ##
                     # Retrieve a single page of InsightsSegmentsInstance records from the API.
                     # Request is executed immediately.
-                    # @param [String] authorization The Authorization HTTP request header
                     # @param [String] segment_id To unique id of the segment
                     # @param [Array[String]] reservation_id The list of reservation Ids
+                    # @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 InsightsSegmentsInstance
-                    def page(authorization: :unset, segment_id: :unset, reservation_id: :unset, page_token: :unset, page_number: :unset,page_size: :unset)
+                    def page(segment_id: :unset, reservation_id: :unset, authorization: :unset, page_token: :unset, page_number: :unset,page_size: :unset)
                         params = Twilio::Values.of({
-                            'Authorization' => authorization,
                             'SegmentId' => segment_id,
                             
                             'ReservationId' =>  Twilio.serialize_list(reservation_id) { |e| e },
@@ -153,7 +151,7 @@ module Twilio
                             'Page' => page_number,
                             'PageSize' => page_size,
                         })
-                        headers = Twilio::Values.of({})
+                        headers = Twilio::Values.of({ 'Authorization' => authorization,  })
                         
                         
 

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

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

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

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

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

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

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

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