twilio-ruby 7.10.7 → 7.11.1

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

@@ -38,8 +38,8 @@ module Twilio
                     # Unlike stream(), this operation is eager and will load `limit` records into
                     # memory before returning.
                     # @param [String] page_token Token for pagination
-                    # @param [Time] created_at_before Filter by Conversations created before this timestamp.
-                    # @param [Time] created_at_after Filter by Conversations created after this timestamp.
+                    # @param [Time] created_at_before Filter by Conversations created before this timestamp. The maximum allowed time range between `createdAtBefore` and `createdAtAfter` is 31 days.
+                    # @param [Time] created_at_after Filter by Conversations created after this timestamp. The maximum allowed time range between `createdAtBefore` and `createdAtAfter` is 31 days.
                     # @param [String] status Filter by Conversation status.
                     # @param [String] channel_id Filters Conversations by the underlying channel resource ID, such as a Call ID or Message ID.
                     # @param [Array[String]] channels Filters Conversations that include one or more of the specified communication channels (`OR` match).
@@ -74,8 +74,8 @@ module Twilio
                     # This operation lazily loads records as efficiently as possible until the limit
                     # is reached.
                     # @param [String] page_token Token for pagination
-                    # @param [Time] created_at_before Filter by Conversations created before this timestamp.
-                    # @param [Time] created_at_after Filter by Conversations created after this timestamp.
+                    # @param [Time] created_at_before Filter by Conversations created before this timestamp. The maximum allowed time range between `createdAtBefore` and `createdAtAfter` is 31 days.
+                    # @param [Time] created_at_after Filter by Conversations created after this timestamp. The maximum allowed time range between `createdAtBefore` and `createdAtAfter` is 31 days.
                     # @param [String] status Filter by Conversation status.
                     # @param [String] channel_id Filters Conversations by the underlying channel resource ID, such as a Call ID or Message ID.
                     # @param [Array[String]] channels Filters Conversations that include one or more of the specified communication channels (`OR` match).
@@ -114,8 +114,8 @@ module Twilio
                     ##
                     # Lists ConversationPageMetadata records from the API as a list.
                       # @param [String] page_token Token for pagination
-                      # @param [Time] created_at_before Filter by Conversations created before this timestamp.
-                      # @param [Time] created_at_after Filter by Conversations created after this timestamp.
+                      # @param [Time] created_at_before Filter by Conversations created before this timestamp. The maximum allowed time range between `createdAtBefore` and `createdAtAfter` is 31 days.
+                      # @param [Time] created_at_after Filter by Conversations created after this timestamp. The maximum allowed time range between `createdAtBefore` and `createdAtAfter` is 31 days.
                       # @param [String] status Filter by Conversation status.
                       # @param [String] channel_id Filters Conversations by the underlying channel resource ID, such as a Call ID or Message ID.
                       # @param [Array[String]] channels Filters Conversations that include one or more of the specified communication channels (`OR` match).
@@ -176,8 +176,8 @@ module Twilio
                     # Retrieve a single page of ConversationInstance records from the API.
                     # Request is executed immediately.
                     # @param [String] page_token Token for pagination
-                    # @param [Time] created_at_before Filter by Conversations created before this timestamp.
-                    # @param [Time] created_at_after Filter by Conversations created after this timestamp.
+                    # @param [Time] created_at_before Filter by Conversations created before this timestamp. The maximum allowed time range between `createdAtBefore` and `createdAtAfter` is 31 days.
+                    # @param [Time] created_at_after Filter by Conversations created after this timestamp. The maximum allowed time range between `createdAtBefore` and `createdAtAfter` is 31 days.
                     # @param [String] status Filter by Conversation status.
                     # @param [String] channel_id Filters Conversations by the underlying channel resource ID, such as a Call ID or Message ID.
                     # @param [Array[String]] channels Filters Conversations that include one or more of the specified communication channels (`OR` match).

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

@@ -0,0 +1,502 @@
+##
+#    This code was generated by
+#    ___ _ _ _ _ _    _ ____    ____ ____ _    ____ ____ _  _ ____ ____ ____ ___ __   __
+#     |  | | | | |    | |  | __ |  | |__| | __ | __ |___ |\ | |___ |__/ |__|  | |  | |__/
+#     |  |_|_| | |___ | |__|    |__| |  | |    |__] |___ | \| |___ |  \ |  |  | |__| |  \
+#
+#    Twilio Conversational Intelligence API
+#    The Conversational Intelligence API includes resources to create and manage intelligence configurations, define and run language operators, and retrieve processed conversations and operator results.  * Use the Configurations resource to create and manage intelligence configurations and define rules that control how and when language operators analyze and transform conversations.  * Use the Operators resource to create custom language operators or retrieve Twilio-author and custom operators. * Use the Conversations resource to retrieve conversations processed with an intelligence configuration, and the OperatorResults resource to retrieve language operator results for those conversations. 
+#
+#    NOTE: This class is auto generated by OpenAPI Generator.
+#    https://openapi-generator.tech
+#    Do not edit the class manually.
+#
+
+
+module Twilio
+    module REST
+        class Intelligence < IntelligenceBase
+            class V3 < Version
+                class RuleExecutionList < ListResource
+                
+                    class CreateRuleExecutionRequest
+                            # @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
+                        def initialize(payload)
+                                @intelligence_configuration_id = payload["intelligence_configuration_id"]
+                                @rule_id = payload["rule_id"]
+                                @conversation_id = payload["conversation_id"]
+                        end
+                        def to_json(options = {})
+                        {
+                                "intelligenceConfigurationId": @intelligence_configuration_id,
+                                "ruleId": @rule_id,
+                                "conversationId": @conversation_id,
+                        }.to_json(options)
+                        end
+                    end
+
+                    class ExecutionDetailsCommunications
+                            # @param [first]: [String] Communication `id` from the attached Conversation.
+                            # @param [last]: [String] Communication `id` from the attached Conversation.
+                        attr_accessor :first, :last
+                        def initialize(payload)
+                                @first = payload["first"]
+                                @last = payload["last"]
+                        end
+                        def to_json(options = {})
+                        {
+                                "first": @first,
+                                "last": @last,
+                        }.to_json(options)
+                        end
+                    end
+
+                    class ExecutionDetailsParticipants
+                            # @param [id]: [String] The `id` of the Participant in the Conversation.
+                            # @param [profile_id]: [String] Customer Memory Profile identifier
+                            # @param [type]: [String] Type of participant in the conversation. Available types: - `CUSTOMER` - `HUMAN_AGENT` - `AI_AGENT` - `AGENT` - `UNKNOWN` 
+                        attr_accessor :id, :profile_id, :type
+                        def initialize(payload)
+                                @id = payload["id"]
+                                @profile_id = payload["profile_id"]
+                                @type = payload["type"]
+                        end
+                        def to_json(options = {})
+                        {
+                                "id": @id,
+                                "profileId": @profile_id,
+                                "type": @type,
+                        }.to_json(options)
+                        end
+                    end
+
+                    class ExecutionDetailsTrigger
+                            # @param [on]: [String] The conversational lifecycle event that activated execution of the Rule. Available values are: - `COMMUNICATION`: Trigger the Rule on each communication within the Conversation. - `CONVERSATION_END`: Trigger the Rule when the Conversation moves to the `closed` state. - `CONVERSATION_INACTIVE`: Trigger the Rule when the Conversation moves to the `inactive` state. 
+                            # @param [timestamp]: [Time] Timestamp of when the trigger was activated.
+                        attr_accessor :on, :timestamp
+                        def initialize(payload)
+                                @on = payload["on"]
+                                @timestamp = payload["timestamp"]
+                        end
+                        def to_json(options = {})
+                        {
+                                "on": @on,
+                                "timestamp": @timestamp,
+                        }.to_json(options)
+                        end
+                    end
+
+                    class ExtractionResultResultEntities
+                            # @param [text]: [String] The actual text of the extracted entity as it appears in the Conversation.
+                            # @param [label]: [String] The label for the extracted entity (e.g., `PERSON`, `LOCATION`).
+                        attr_accessor :text, :label
+                        def initialize(payload)
+                                @text = payload["text"]
+                                @label = payload["label"]
+                        end
+                        def to_json(options = {})
+                        {
+                                "text": @text,
+                                "label": @label,
+                        }.to_json(options)
+                        end
+                    end
+
+                    class ResolvedContext
+                            # @param [memory]: [ResolvedContextMemory] 
+                            # @param [knowledge]: [ResolvedContextKnowledge] 
+                        attr_accessor :memory, :knowledge
+                        def initialize(payload)
+                                @memory = payload["memory"]
+                                @knowledge = payload["knowledge"]
+                        end
+                        def to_json(options = {})
+                        {
+                                "memory": @memory,
+                                "knowledge": @knowledge,
+                        }.to_json(options)
+                        end
+                    end
+
+                    class ResolvedContextKnowledge
+                            # @param [sources]: [Array<ResolvedContextKnowledgeSources>] 
+                        attr_accessor :sources
+                        def initialize(payload)
+                                @sources = payload["sources"]
+                        end
+                        def to_json(options = {})
+                        {
+                                "sources": @sources,
+                        }.to_json(options)
+                        end
+                    end
+
+                    class ResolvedContextKnowledgeSources
+                            # @param [base_id]: [String] Knowledge base identifier
+                            # @param [source_id]: [String] Knowledge source identifier
+                        attr_accessor :base_id, :source_id
+                        def initialize(payload)
+                                @base_id = payload["base_id"]
+                                @source_id = payload["source_id"]
+                        end
+                        def to_json(options = {})
+                        {
+                                "baseId": @base_id,
+                                "sourceId": @source_id,
+                        }.to_json(options)
+                        end
+                    end
+
+                    class ResolvedContextMemory
+                            # @param [profile_id]: [String] Customer Memory Profile identifier
+                            # @param [memory_store_id]: [String] Customer Memory store identifier
+                        attr_accessor :profile_id, :memory_store_id
+                        def initialize(payload)
+                                @profile_id = payload["profile_id"]
+                                @memory_store_id = payload["memory_store_id"]
+                        end
+                        def to_json(options = {})
+                        {
+                                "profileId": @profile_id,
+                                "memoryStoreId": @memory_store_id,
+                        }.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.
+                            # @param [input_characters]: [Integer] Number of characters in the input sent to the model. Aligns with the billing unit.
+                            # @param [output_characters]: [Integer] Number of characters in the model's response. Aligns with the billing unit.
+                            # @param [input_truncated]: [Boolean] Whether the conversation input was truncated to fit the model's context window.
+                        attr_accessor :resolved_model, :latency_ms, :input_characters, :output_characters, :input_truncated
+                        def initialize(payload)
+                                @resolved_model = payload["resolved_model"]
+                                @latency_ms = payload["latency_ms"]
+                                @input_characters = payload["input_characters"]
+                                @output_characters = payload["output_characters"]
+                                @input_truncated = payload["input_truncated"]
+                        end
+                        def to_json(options = {})
+                        {
+                                "resolvedModel": @resolved_model,
+                                "latencyMs": @latency_ms,
+                                "inputCharacters": @input_characters,
+                                "outputCharacters": @output_characters,
+                                "inputTruncated": @input_truncated,
+                        }.to_json(options)
+                        end
+                    end
+
+
+                    ##
+                    # Initialize the RuleExecutionList
+                    # @param [Version] version Version that contains the resource
+                    # @return [RuleExecutionList] RuleExecutionList
+                    def initialize(version)
+                        
+                        apiV1Version = ApiV1Version.new version.domain, version
+                        super(apiV1Version)
+                        # Path Solution
+                        @solution = {  }
+                        @uri = "/RuleExecutions"
+                        
+                    end
+                    ##
+                    # Create the RuleExecutionInstance
+                    # @param [CreateRuleExecutionRequest] create_rule_execution_request 
+                    # @return [RuleExecutionInstance] Created RuleExecutionInstance
+                    def create(create_rule_execution_request: nil
+                    )
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        headers['Content-Type'] = 'application/json'
+                        
+                        
+                        
+                        
+                        payload = @version.create('POST', @uri, headers: headers, data: create_rule_execution_request.to_json)
+                        RuleExecutionInstance.new(
+                            @version,
+                            payload,
+                        )
+                    end
+
+                    ##
+                    # Create the RuleExecutionInstanceMetadata
+                    # @param [CreateRuleExecutionRequest] create_rule_execution_request 
+                    # @return [RuleExecutionInstance] Created RuleExecutionInstance
+                    def create_with_metadata(create_rule_execution_request: nil
+                    )
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        headers['Content-Type'] = 'application/json'
+                        
+                        
+                        
+                        
+                        response = @version.create_with_metadata('POST', @uri, headers: headers, data: create_rule_execution_request.to_json)
+                        rule_execution_instance = RuleExecutionInstance.new(
+                            @version,
+                            response.body,
+                        )
+                        RuleExecutionInstanceMetadata.new(
+                            @version,
+                            rule_execution_instance,
+                            response.headers,
+                            response.status_code
+                        )
+                    end
+
+                
+
+
+                    # Provide a user friendly representation
+                    def to_s
+                        '#<Twilio.Intelligence.V3.RuleExecutionList>'
+                    end
+                end
+
+                class RuleExecutionPage < TokenPage
+                    ##
+                    # Initialize the RuleExecutionPage
+                    # @param [Version] version Version that contains the resource
+                    # @param [Response] response Response from the API
+                    # @param [Hash] solution Path solution for the resource
+                    # @return [RuleExecutionPage] RuleExecutionPage
+                    def initialize(version, response, solution)
+                        
+                        apiV1Version = ApiV1Version.new version.domain, version
+                        super(apiV1Version, response)
+
+                        # Path Solution
+                        @solution = solution
+                    end
+
+                    ##
+                    # Build an instance of RuleExecutionInstance
+                    # @param [Hash] payload Payload response from the API
+                    # @return [RuleExecutionInstance] RuleExecutionInstance
+                    def get_instance(payload)
+                        RuleExecutionInstance.new(@version, payload)
+                    end
+
+                    ##
+                    # Provide a user friendly representation
+                    def to_s
+                        '<Twilio.Intelligence.V3.RuleExecutionPage>'
+                    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
+                    # @param [Version] version Version that contains the resource
+                    # @param [Hash] payload payload that contains response from Twilio
+                    # @param [String] account_sid The SID of the
+                    #   {Account}[https://www.twilio.com/docs/iam/api/account] that created this RuleExecution
+                    #   resource.
+                    # @param [String] sid The SID of the Call resource to fetch.
+                    # @return [RuleExecutionInstance] RuleExecutionInstance
+                    def initialize(version, payload )
+                        
+                        apiV1Version = ApiV1Version.new version.domain, version
+                        super(apiV1Version)
+                        
+                        # Marshaled Properties
+                        @properties = { 
+                            'code' => payload['code'],
+                            'message' => payload['message'],
+                            'http_status_code' => payload['http_status_code'],
+                            'user_error' => payload['user_error'],
+                            'params' => payload['params'],
+                            'output_format' => payload['output_format'],
+                            'id' => payload['id'],
+                            'account_id' => payload['account_id'],
+                            'intelligence_configuration' => payload['intelligence_configuration'],
+                            'conversation_id' => payload['conversation_id'],
+                            'operator' => payload['operator'],
+                            'date_created' => Twilio.deserialize_iso8601_datetime(payload['date_created']),
+                            'reference_ids' => payload['reference_ids'],
+                            'execution_details' => payload['execution_details'],
+                            'metadata' => payload['metadata'],
+                            'result' => payload['result'],
+                        }
+                    end
+
+                    
+                    ##
+                    # @return [String] Twilio-specific error code
+                    def code
+                        @properties['code']
+                    end
+                    
+                    ##
+                    # @return [String] A human readable error message
+                    def message
+                        @properties['message']
+                    end
+                    
+                    ##
+                    # @return [String] HTTP response status code
+                    def http_status_code
+                        @properties['http_status_code']
+                    end
+                    
+                    ##
+                    # @return [Boolean] Whether the error is a user error (true) or a system error (false)
+                    def user_error
+                        @properties['user_error']
+                    end
+                    
+                    ##
+                    # @return [Hash<String, String>] A map of parameters related to the error, for example, a `params.twilioErrorCodeUrl` might hold a URL or link to additional information
+                    def params
+                        @properties['params']
+                    end
+                    
+                    ##
+                    # @return [String] The output format set on the Operator that generated this result. Determines the structure of the `result` object.
+                    def output_format
+                        @properties['output_format']
+                    end
+                    
+                    ##
+                    # @return [String] A unique identifier for the Operator Result. Assigned by Twilio (TTID).
+                    def id
+                        @properties['id']
+                    end
+                    
+                    ##
+                    # @return [String] The ID of the Account that created the Language Operator.
+                    def account_id
+                        @properties['account_id']
+                    end
+                    
+                    ##
+                    # @return [IntelligenceConfigurationReference] 
+                    def intelligence_configuration
+                        @properties['intelligence_configuration']
+                    end
+                    
+                    ##
+                    # @return [String] The `id` of the Conversation attached to the Operator Result.
+                    def conversation_id
+                        @properties['conversation_id']
+                    end
+                    
+                    ##
+                    # @return [OperatorReference] 
+                    def operator
+                        @properties['operator']
+                    end
+                    
+                    ##
+                    # @return [Time] Timestamp for when the Operator Result was created.
+                    def date_created
+                        @properties['date_created']
+                    end
+                    
+                    ##
+                    # @return [Array<String>] The `id`s of objects related to this Operator Result.
+                    def reference_ids
+                        @properties['reference_ids']
+                    end
+                    
+                    ##
+                    # @return [ExecutionDetails] 
+                    def execution_details
+                        @properties['execution_details']
+                    end
+                    
+                    ##
+                    # @return [OperatorResultsResponseBaseMetadata] 
+                    def metadata
+                        @properties['metadata']
+                    end
+                    
+                    ##
+                    # @return [ExtractionResultResult] 
+                    def result
+                        @properties['result']
+                    end
+                    
+                    ##
+                    # Provide a user friendly representation
+                    def to_s
+                        "<Twilio.Intelligence.V3.RuleExecutionInstance>"
+                    end
+
+                    ##
+                    # Provide a detailed, user friendly representation
+                    def inspect
+                        "<Twilio.Intelligence.V3.RuleExecutionInstance>"
+                    end
+                end
+
+            end
+        end
+    end
+end

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

@@ -25,6 +25,7 @@ module Twilio
                     @conversations = nil
                     @operators = nil
                     @operator_results = nil
+                    @rule_executions = nil
                     @versions = nil
                 end
 
@@ -89,6 +90,11 @@ module Twilio
                     end
                 end
                 ##
+                # @return [Twilio::REST::Intelligence::V3::RuleExecutionList]
+                def rule_executions
+                    @rule_executions ||= RuleExecutionList.new self
+                end
+                ##
                 # @param [String] id The unique identifier (TTID) of the Language Operator.
                 # @param [String] version
                 # @return [Twilio::REST::Intelligence::V3::VersionContext] if version was passed.

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

@@ -271,6 +271,10 @@ module Twilio
                         @properties = { 
                             'content' => payload['content'],
                             'created_at' => Twilio.deserialize_iso8601_datetime(payload['created_at']),
+                            'chunk_index' => payload['chunk_index'] == nil ? payload['chunk_index'] : payload['chunk_index'].to_i,
+                            'document_title' => payload['document_title'],
+                            'document_url' => payload['document_url'],
+                            'document_number' => payload['document_number'] == nil ? payload['document_number'] : payload['document_number'].to_i,
                         }
                     end
 
@@ -287,6 +291,30 @@ module Twilio
                         @properties['created_at']
                     end
                     
+                    ##
+                    # @return [String] 0-based position of this chunk within its source document for a single ingestion run.
+                    def chunk_index
+                        @properties['chunk_index']
+                    end
+                    
+                    ##
+                    # @return [String] Human-readable title of the source document. Web: HTML <title> from the crawled page. File: filename from Unstructured metadata. Text: knowledge name from the knowledge source.
+                    def document_title
+                        @properties['document_title']
+                    end
+                    
+                    ##
+                    # @return [String] Specific page URL this chunk was crawled from. Web sources only; null for File and Text sources.
+                    def document_url
+                        @properties['document_url']
+                    end
+                    
+                    ##
+                    # @return [String] Physical page number (1-based). PDF sources only; omitted for all other source types.
+                    def document_number
+                        @properties['document_number']
+                    end
+                    
                     ##
                     # Provide a user friendly representation
                     def to_s

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

@@ -38,6 +38,44 @@ module Twilio
                         end
                     end
 
+                    class KnowledgeErrorGroup
+                            # @param [title]: [String] The error type or reason (e.g., \"404 Not Found\", \"500 Internal Server Error\").
+                            # @param [instances]: [Array<KnowledgeList.KnowledgeErrorInstance>] Array of error instances for this error title. Required when an error group is present.
+                        attr_accessor :title, :instances
+                        def initialize(payload)
+                                @title = payload["title"]
+                                @instances = payload["instances"]
+                        end
+                        def to_json(options = {})
+                        {
+                                "title": @title,
+                                "instances": @instances,
+                        }.to_json(options)
+                        end
+                    end
+
+                    class KnowledgeErrorInstance
+                            # @param [type]: [String] A URI reference identifying the problem type, resolving to human-readable documentation (e.g., https://www.twilio.com/docs/api/errors/420018).
+                            # @param [code]: [String] Twilio-specific numeric error code for programmatic handling.
+                            # @param [instance]: [String] The specific URL or resource that caused the error.
+                            # @param [detail]: [String] Detailed explanation of the error.
+                        attr_accessor :type, :code, :instance, :detail
+                        def initialize(payload)
+                                @type = payload["type"]
+                                @code = payload["code"]
+                                @instance = payload["instance"]
+                                @detail = payload["detail"]
+                        end
+                        def to_json(options = {})
+                        {
+                                "type": @type,
+                                "code": @code,
+                                "instance": @instance,
+                                "detail": @detail,
+                        }.to_json(options)
+                        end
+                    end
+
 
                     ##
                     # Initialize the KnowledgeList