twilio-ruby 7.11.1 → 7.11.3

data/lib/twilio-ruby/rest/intelligence/v3/rule_execution.rb

@@ -23,17 +23,20 @@ module Twilio
                             # @param [intelligence_configuration_id]: [String] The Intelligence Configuration identifier to execute the Rule within.
                             # @param [rule_id]: [String] The rule identifier to execute within the selected Intelligence Configuration.
                             # @param [conversation_id]: [String] The Conversation identifier to execute the Rule against.
-                        attr_accessor :intelligence_configuration_id, :rule_id, :conversation_id
+                            # @param [rule]: [RuleExecutionList.RuleOverride] 
+                        attr_accessor :intelligence_configuration_id, :rule_id, :conversation_id, :rule
                         def initialize(payload)
                                 @intelligence_configuration_id = payload["intelligence_configuration_id"]
                                 @rule_id = payload["rule_id"]
                                 @conversation_id = payload["conversation_id"]
+                                @rule = payload["rule"]
                         end
                         def to_json(options = {})
                         {
                                 "intelligenceConfigurationId": @intelligence_configuration_id,
                                 "ruleId": @rule_id,
                                 "conversationId": @conversation_id,
+                                "rule": @rule,
                         }.to_json(options)
                         end
                     end
@@ -105,6 +108,22 @@ module Twilio
                         end
                     end
 
+                    class OperatorOverride
+                            # @param [id]: [String] The operator id (as configured in the stored rule) to override.
+                            # @param [parameters]: [Hash<String, Object>] Parameter overrides merged into the stored operator's parameters.
+                        attr_accessor :id, :parameters
+                        def initialize(payload)
+                                @id = payload["id"]
+                                @parameters = payload["parameters"]
+                        end
+                        def to_json(options = {})
+                        {
+                                "id": @id,
+                                "parameters": @parameters,
+                        }.to_json(options)
+                        end
+                    end
+
                     class ResolvedContext
                             # @param [memory]: [ResolvedContextMemory] 
                             # @param [knowledge]: [ResolvedContextKnowledge] 
@@ -166,6 +185,19 @@ module Twilio
                         end
                     end
 
+                    class RuleOverride
+                            # @param [operators]: [Array<RuleExecutionList.OperatorOverride>] Operator parameter overrides, merged key-by-key into the stored operator's parameters (override wins on matching keys; unspecified keys retain their stored values). Operators in the stored rule not referenced here execute with their stored parameters unchanged. 
+                        attr_accessor :operators
+                        def initialize(payload)
+                                @operators = payload["operators"]
+                        end
+                        def to_json(options = {})
+                        {
+                                "operators": @operators,
+                        }.to_json(options)
+                        end
+                    end
+
                     class SystemMetaData
                             # @param [resolved_model]: [String] The underlying LLM model used for this execution.
                             # @param [latency_ms]: [Integer] Operator execution time in milliseconds.
@@ -291,65 +323,6 @@ module Twilio
                     end
                 end
 
-                class RuleExecutionPageMetadata < PageMetadata
-                    attr_reader :rule_execution_page
-
-                    def initialize(version, response, solution, limit)
-                        super(version, response)
-                        @rule_execution_page = []
-                        @limit = limit
-                        key = get_key(response.body)
-                        records = 0
-                        while( limit != :unset && records < limit )
-                            @rule_execution_page << RuleExecutionListResponse.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
-                        @rule_execution_page.each do |record|
-                          yield record
-                        end
-                    end
-
-                    def to_s
-                      '<Twilio::REST::Intelligence::V3PageMetadata>';
-                    end
-                end
-                class RuleExecutionListResponse < InstanceListResource
-
-                    # @param [Array<RuleExecutionInstance>] 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
-                      @rule_execution = data_list.map do |data|
-                        RuleExecutionInstance.new(version, data)
-                      end
-                      @headers = payload.headers
-                      @status_code = payload.status_code
-                    end
-
-                    def rule_execution
-                        @rule_execution
-                    end
-
-                    def headers
-                      @headers
-                    end
-
-                    def status_code
-                      @status_code
-                    end
-                end
-
                 class RuleExecutionInstance < InstanceResource
                     ##
                     # Initialize the RuleExecutionInstance

data/lib/twilio-ruby/rest/knowledge/v1/knowledge/knowledge_status.rb

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

data/lib/twilio-ruby/rest/knowledge/v2/operation.rb

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

data/lib/twilio-ruby/rest/knowledge/v2/search.rb

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

data/lib/twilio-ruby/rest/lookups/v1/phone_number.rb

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

data/lib/twilio-ruby/rest/lookups/v2/bucket.rb

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

data/lib/twilio-ruby/rest/lookups/v2/lookup_override.rb

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

data/lib/twilio-ruby/rest/lookups/v2/phone_number.rb

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

data/lib/twilio-ruby/rest/lookups/v2/query.rb

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