twilio-ruby 7.10.5 → 7.10.6

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

@@ -0,0 +1,784 @@
+##
+#    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 OperatorList < ListResource
+                
+                    class LanguageOperator
+                            # @param [id]: [String] The unique identifier for the Language Operator. Assigned by Twilio (TTID).
+                            # @param [display_name]: [String] Display name of the Language Operator describing its purpose.
+                            # @param [description]: [String] Description of the Language Operator further explaining its purpose.
+                            # @param [version]: [String] Numeric Operator version. Automatically incremented with each update on the resource, used to ensure integrity when updating the Operator.
+                            # @param [author]: ["OperatorInstance.OperatorAuthor"] 
+                            # @param [prompt]: [String] The natural language instructions used by the operator to analyze the conversation.  Within the prompt, users can reference parameters using the `{{parameters.[param_name]}}` syntax. Parameter values are provided to the Operator by the Intelligence Configuration Rule at runtime.  **Note**: Prompts will only be exposed for Custom Operators (`author` = `SELF`). Twilio-authored Operators (`author` = `TWILIO`) will have their prompts omitted from the API.
+                            # @param [output_format]: [OperatorOutputFormat] 
+                            # @param [output_schema]: [Hash] Required for `JSON` output only. this will be set to a JSON Schema object describing the properties & data types of the response. Please see https://platform.openai.com/docs/guides/structured-outputs#supported-schemas   Will include the following keywords: - `type` : Must be set to `object` - `properties`:  An object containing the property names and their data types you would like the LLM to return  Additional details on JSON output formatting: - The root level `type` of a JSON schema must be set to `object` - The following property data types are supported : `string`, `number`, `boolean`, `integer`, `object`, `array`, `anyOf` - Definitions with `$defs` / `$ref` are supported - Max 100 object properties and 10 levels of nesting are supported - Max 1000 enum values across all enum properties are supported - Notable JSON Schema keywords not supported include:   - For `strings`: `minLength`, `maxLength`   - For `objects`: `patternProperties`, `unevaluatedProperties`, `propertyNames`, `minProperties`, `maxProperties`   - For `arrays`: `unevaluatedItems`, `contains`, `minContains`, `maxContains`, `uniqueItems` - Structured Operator Results will be returned in the same order as the ordering of keys in the schema - In the event an Operator execution request is refused for safety reasons the Operator Result API response will include a new field called `refusal` to indicate that the LLM refused to fulfill the request - Twilio will automatically set `additionalProperties` to false and specify all provided fields as required (constraints of Structured Outputs). You don't need to pass these fields as part of your JSON schema. Twilio will automatically overwrite any user-provided values for these fields.
+                            # @param [training_examples]: [Array<OperatorList.OperatorTrainingExample>] An array of example input/output pairs used to illustrate the intended behavior of the Language Operator. These examples help guide the model's understanding of expected input–output relationships and improve consistency during evaluation and testing.  **Note**: Training examples will only be exposed for Custom Operators (`author` = `SELF`). Twilio-authored Operators (`author` = `TWILIO`) will have their training examples omitted from the API.
+                            # @param [context]: [OperatorList.OperatorContext] 
+                            # @param [parameters]: [Hash<String, OperatorParameter>] Defines the schema of the parameters that are provided when running the operator, including required and optional values that determine the operator's behavior. The values of the parameters themselves are passed in by the attached Intelligence Configuration.
+                        attr_accessor :id, :display_name, :description, :version, :author, :prompt, :output_format, :output_schema, :training_examples, :context, :parameters
+                        def initialize(payload)
+                                @id = payload["id"]
+                                @display_name = payload["display_name"]
+                                @description = payload["description"]
+                                @version = payload["version"]
+                                @author = payload["author"]
+                                @prompt = payload["prompt"]
+                                @output_format = payload["output_format"]
+                                @output_schema = payload["output_schema"]
+                                @training_examples = payload["training_examples"]
+                                @context = payload["context"]
+                                @parameters = payload["parameters"]
+                        end
+                        def to_json(options = {})
+                        {
+                                "id": @id,
+                                "displayName": @display_name,
+                                "description": @description,
+                                "version": @version,
+                                "author": @author,
+                                "prompt": @prompt,
+                                "outputFormat": @output_format,
+                                "outputSchema": @output_schema,
+                                "trainingExamples": @training_examples,
+                                "context": @context,
+                                "parameters": @parameters,
+                        }.to_json(options)
+                        end
+                    end
+
+                    class OperatorContextKnowledge
+                            # @param [enabled]: [Boolean] Set to true to allow access to Knowledge Sources at runtime.
+                        attr_accessor :enabled
+                        def initialize(payload)
+                                @enabled = payload["enabled"]
+                        end
+                        def to_json(options = {})
+                        {
+                                "enabled": @enabled,
+                        }.to_json(options)
+                        end
+                    end
+
+                    class OperatorContextMemory
+                            # @param [enabled]: [Boolean] Set to true to allow access to Memory at runtime.
+                        attr_accessor :enabled
+                        def initialize(payload)
+                                @enabled = payload["enabled"]
+                        end
+                        def to_json(options = {})
+                        {
+                                "enabled": @enabled,
+                        }.to_json(options)
+                        end
+                    end
+
+
+                    ##
+                    # Initialize the OperatorList
+                    # @param [Version] version Version that contains the resource
+                    # @return [OperatorList] OperatorList
+                    def initialize(version)
+                        
+                        apiV1Version = ApiV1Version.new version.domain, version
+                        super(apiV1Version)
+                        # Path Solution
+                        @solution = {  }
+                        @uri = "/ControlPlane/Operators"
+                        
+                    end
+                    ##
+                    # Create the OperatorInstance
+                    # @param [LanguageOperator] language_operator Create Language Operator request
+                    # @return [OperatorInstance] Created OperatorInstance
+                    def create(language_operator: 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: language_operator.to_json)
+                        OperatorInstance.new(
+                            @version,
+                            payload,
+                        )
+                    end
+
+                    ##
+                    # Create the OperatorInstanceMetadata
+                    # @param [LanguageOperator] language_operator Create Language Operator request
+                    # @return [OperatorInstance] Created OperatorInstance
+                    def create_with_metadata(language_operator: 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: language_operator.to_json)
+                        operator_instance = OperatorInstance.new(
+                            @version,
+                            response.body,
+                        )
+                        OperatorInstanceMetadata.new(
+                            @version,
+                            operator_instance,
+                            response.headers,
+                            response.status_code
+                        )
+                    end
+
+                
+                    ##
+                    # Lists OperatorInstance records from the API as a list.
+                    # Unlike stream(), this operation is eager and will load `limit` records into
+                    # memory before returning.
+                    # @param [String] page_token Token for pagination
+                    # @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
+                    #    not set will use the default value of 50 records.  If no page_size is defined
+                    #    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(page_token: :unset, limit: nil, page_size: nil)
+                        self.stream(
+                            page_token: page_token,
+                            limit: limit,
+                            page_size: page_size
+                        ).entries
+                    end
+
+                    ##
+                    # 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] page_token Token for pagination
+                    # @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
+                    #    not set will use the default value of 50 records.  If no page_size is defined
+                    #    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(page_token: :unset, limit: nil, page_size: nil)
+                        limits = @version.read_limits(limit, page_size)
+
+                        page = self.page(
+                            page_token: page_token,
+                            page_size: limits[:page_size], )
+
+                        return [].each if page.nil?
+
+                        result = @version.stream(page, limit: limits[:limit], page_limit: limits[:page_limit])
+                        return [].each if result.nil?
+                        result
+                    end
+
+                    ##
+                    # Lists OperatorPageMetadata records from the API as a list.
+                      # @param [String] page_token Token for pagination
+                    # @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
+                    #    not set will use the default value of 50 records.  If no page_size is defined
+                    #    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(page_token: :unset, limit: nil, page_size: nil)
+                        limits = @version.read_limits(limit, page_size)
+                        params = Twilio::Values.of({
+                            'pageToken' => page_token,
+                            
+                            'PageSize' => limits[:page_size],
+                        });
+                        headers = Twilio::Values.of({})
+
+                        response = @version.page('GET', @uri, params: params, headers: headers)
+
+                        OperatorPageMetadata.new(@version, response, @solution, limits[:limit])
+                    end
+
+                    ##
+                    # When passed a block, yields OperatorInstance records from the API.
+                    # This operation lazily loads records as efficiently as possible until the limit
+                    # is reached.
+                    def each
+                        limits = @version.read_limits
+
+                        page = self.page(page_size: limits[:page_size], )
+
+                        return [].each if page.nil?
+
+                        result = @version.stream(page,
+                            limit: limits[:limit],
+                            page_limit: limits[:page_limit])
+                        return [].each if result.nil?
+                        result.each {|x| yield x}
+                    end
+
+                    ##
+                    # Retrieve a single page of OperatorInstance records from the API.
+                    # Request is executed immediately.
+                    # @param [String] page_token Token for pagination
+                    
+                    # @return [Page] Page of OperatorInstance
+                    def page(page_token: :unset, page_size: :unset)
+                        params = Twilio::Values.of({
+                            'pageToken' => page_token,
+                                                        'PageSize' => page_size,
+                        })
+                        headers = Twilio::Values.of({})
+                        
+                        
+
+                        response = @version.page('GET', @uri, params: params, headers: headers)
+
+                        OperatorPage.new(@version, response, @solution)
+                    end
+
+                    ##
+                    # Retrieve a single page of OperatorInstance records from the API.
+                    # Request is executed immediately.
+                    # @param [String] target_url API-generated URL for the requested results page
+                    # @return [Page] Page of OperatorInstance
+                    def get_page(target_url)
+                        response = @version.domain.request(
+                            'GET',
+                            target_url
+                        )
+                    OperatorPage.new(@version, response, @solution)
+                    end
+                    
+
+
+                    # Provide a user friendly representation
+                    def to_s
+                        '#<Twilio.Intelligence.V3.OperatorList>'
+                    end
+                end
+
+
+                class OperatorContext < InstanceContext
+                    ##
+                    # Initialize the OperatorContext
+                    # @param [Version] version Version that contains the resource
+                    # @param [String] id The unique identifier (TTID) of the Language Operator.
+                    # @return [OperatorContext] OperatorContext
+                    def initialize(version, id)
+                        
+                        apiV1Version = ApiV1Version.new version.domain, version
+                        super(apiV1Version)
+
+                        # Path Solution
+                        @solution = { id: id,  }
+                        @uri = "/ControlPlane/Operators/#{@solution[:id]}"
+
+                        
+                    end
+                    ##
+                    # Delete the OperatorInstance
+                    # @return [Boolean] True if delete succeeds, false otherwise
+                    def delete
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                        response = @version.delete_with_metadata('DELETE', @uri, headers: headers)
+                        OperatorInstance.new(
+                          @version,
+                          response.body,
+                            id: @solution[:id],
+                        )
+                        
+                    end
+
+                    ##
+                    # Delete the OperatorInstanceMetadata
+                    # @return [Boolean] True if delete succeeds, false otherwise
+                    def delete_with_metadata
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                          response = @version.delete_with_metadata('DELETE', @uri, headers: headers)
+                          operator_instance = OperatorInstance.new(
+                              @version,
+                              response.body,
+                              account_sid: @solution[:account_sid],
+                              sid: @solution[:sid],
+                          )
+                          OperatorInstanceMetadata.new(@version, operator_instance, response.headers, response.status_code)
+                    end
+
+                    ##
+                    # Fetch the OperatorInstance
+                    # @return [OperatorInstance] Fetched OperatorInstance
+                    def fetch
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                        
+                        
+                        payload = @version.fetch('GET', @uri, headers: headers)
+                        OperatorInstance.new(
+                            @version,
+                            payload,
+                            id: @solution[:id],
+                        )
+                    end
+
+                    ##
+                    # Fetch the OperatorInstanceMetadata
+                    # @return [OperatorInstance] Fetched OperatorInstance
+                    def fetch_with_metadata
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                        
+                        
+                        response = @version.fetch_with_metadata('GET', @uri, headers: headers)
+                        operator_instance = OperatorInstance.new(
+                            @version,
+                            response.body,
+                            id: @solution[:id],
+                        )
+                        OperatorInstanceMetadata.new(
+                            @version,
+                            operator_instance,
+                            response.headers,
+                            response.status_code
+                        )
+                    end
+
+                    ##
+                    # Update the OperatorInstance
+                    # @param [String] if_match Current ETag/version required for conditional update
+                    # @param [LanguageOperator] language_operator Full replacement of a Language Operator configuration
+                    # @return [OperatorInstance] Updated OperatorInstance
+                    def update(
+                      if_match: :unset,
+                      language_operator: nil
+                    )
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', 'If-Match' => if_match, })
+                        headers['Content-Type'] = 'application/json'
+                        
+                        
+                        
+                        
+                        payload = @version.update('PUT', @uri, headers: headers, data: language_operator.to_json)
+                        OperatorInstance.new(
+                            @version,
+                            payload,
+                            id: @solution[:id],
+                        )
+                    end
+
+                    ##
+                    # Update the OperatorInstanceMetadata
+                    # @param [String] if_match Current ETag/version required for conditional update
+                    # @param [LanguageOperator] language_operator Full replacement of a Language Operator configuration
+                    # @return [OperatorInstance] Updated OperatorInstance
+                    def update_with_metadata(
+                      if_match: :unset,
+                    language_operator: nil
+                    )
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', 'If-Match' => if_match, })
+                        headers['Content-Type'] = 'application/json'
+                        
+                        
+                        
+                        
+                        response = @version.update_with_metadata('PUT', @uri, headers: headers, data: language_operator.to_json)
+                        operator_instance = OperatorInstance.new(
+                            @version,
+                            response.body,
+                            id: @solution[:id],
+                        )
+                        OperatorInstanceMetadata.new(
+                            @version,
+                            operator_instance,
+                            response.headers,
+                            response.status_code
+                        )
+                    end
+
+
+                    ##
+                    # Provide a user friendly representation
+                    def to_s
+                        context = @solution.map{|k, v| "#{k}: #{v}"}.join(',')
+                        "#<Twilio.Intelligence.V3.OperatorContext #{context}>"
+                    end
+
+                    ##
+                    # Provide a detailed, user friendly representation
+                    def inspect
+                        context = @solution.map{|k, v| "#{k}: #{v}"}.join(',')
+                        "#<Twilio.Intelligence.V3.OperatorContext #{context}>"
+                    end
+                end
+
+                class OperatorInstanceMetadata <  InstanceResourceMetadata
+                    ##
+                    # Initializes a new OperatorInstanceMetadata.
+                    # @param [Version] version Version that contains the resource
+                    # @param [}OperatorInstance] operator_instance The instance associated with the metadata.
+                    # @param [Hash] headers Header object with response headers.
+                    # @param [Integer] status_code The HTTP status code of the response.
+                    # @return [OperatorInstanceMetadata] The initialized instance with metadata.
+                    def initialize(version, operator_instance, headers, status_code)
+                        super(version, headers, status_code)
+                        @operator_instance = operator_instance
+                    end
+
+                    def operator
+                        @operator_instance
+                    end
+
+                    def headers
+                        @headers
+                    end
+
+                    def status_code
+                        @status_code
+                    end
+
+                    def to_s
+                      "<Twilio.Api.V2010.OperatorInstanceMetadata status=#{@status_code}>"
+                    end
+                end
+
+                class OperatorListResponse < InstanceListResource
+                    # @param [Array<OperatorInstance>] instance
+                    # @param [Hash{String => Object}] headers
+                    # @param [Integer] status_code
+                    def initialize(version, payload, key)
+                       @operator_instance = payload.body[key].map do |data|
+                        OperatorInstance.new(version, data)
+                       end
+                       @headers = payload.headers
+                       @status_code = payload.status_code
+                    end
+
+                      def operator_instance
+                          @instance
+                      end
+                  end
+
+                class OperatorPage < TokenPage
+                    ##
+                    # Initialize the OperatorPage
+                    # @param [Version] version Version that contains the resource
+                    # @param [Response] response Response from the API
+                    # @param [Hash] solution Path solution for the resource
+                    # @return [OperatorPage] OperatorPage
+                    def initialize(version, response, solution)
+                        
+                        apiV1Version = ApiV1Version.new version.domain, version
+                        super(apiV1Version, response)
+
+                        # Path Solution
+                        @solution = solution
+                    end
+
+                    ##
+                    # Build an instance of OperatorInstance
+                    # @param [Hash] payload Payload response from the API
+                    # @return [OperatorInstance] OperatorInstance
+                    def get_instance(payload)
+                        OperatorInstance.new(@version, payload)
+                    end
+
+                    ##
+                    # Provide a user friendly representation
+                    def to_s
+                        '<Twilio.Intelligence.V3.OperatorPage>'
+                    end
+                end
+
+                class OperatorPageMetadata < PageMetadata
+                    attr_reader :operator_page
+
+                    def initialize(version, response, solution, limit)
+                        super(version, response)
+                        @operator_page = []
+                        @limit = limit
+                        key = get_key(response.body)
+                        records = 0
+                        while( limit != :unset && records < limit )
+                            @operator_page << OperatorListResponse.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
+                        @operator_page.each do |record|
+                          yield record
+                        end
+                    end
+
+                    def to_s
+                      '<Twilio::REST::Intelligence::V3PageMetadata>';
+                    end
+                end
+                class OperatorListResponse < InstanceListResource
+
+                    # @param [Array<OperatorInstance>] 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
+                      @operator = data_list.map do |data|
+                        OperatorInstance.new(version, data)
+                      end
+                      @headers = payload.headers
+                      @status_code = payload.status_code
+                    end
+
+                    def operator
+                        @operator
+                    end
+
+                    def headers
+                      @headers
+                    end
+
+                    def status_code
+                      @status_code
+                    end
+                end
+
+                class OperatorInstance < InstanceResource
+                    ##
+                    # Initialize the OperatorInstance
+                    # @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 Operator
+                    #   resource.
+                    # @param [String] sid The SID of the Call resource to fetch.
+                    # @return [OperatorInstance] OperatorInstance
+                    def initialize(version, payload , id: nil)
+                        
+                        apiV1Version = ApiV1Version.new version.domain, version
+                        super(apiV1Version)
+                        
+                        # Marshaled Properties
+                        @properties = { 
+                            'id' => payload['id'],
+                            'display_name' => payload['display_name'],
+                            'description' => payload['description'],
+                            'version' => payload['version'] == nil ? payload['version'] : payload['version'].to_i,
+                            'author' => payload['author'],
+                            'prompt' => payload['prompt'],
+                            'output_format' => payload['output_format'],
+                            'output_schema' => payload['output_schema'],
+                            'training_examples' => payload['training_examples'],
+                            'context' => payload['context'],
+                            'parameters' => payload['parameters'],
+                            'code' => payload['code'],
+                            'message' => payload['message'],
+                            'http_status_code' => payload['http_status_code'],
+                            'user_error' => payload['user_error'],
+                            'params' => payload['params'],
+                        }
+
+                        # Context
+                        @instance_context = nil
+                        @params = { 'id' => id  || @properties['id']  , }
+                    end
+
+                    ##
+                    # Generate an instance context for the instance, the context is capable of
+                    # performing various actions.  All instance actions are proxied to the context
+                    # @return [OperatorContext] CallContext for this CallInstance
+                    def context
+                        unless @instance_context
+                            @instance_context = OperatorContext.new(@version , @params['id'])
+                        end
+                        @instance_context
+                    end
+                    
+                    ##
+                    # @return [String] The unique identifier for the Language Operator. Assigned by Twilio (TTID).
+                    def id
+                        @properties['id']
+                    end
+                    
+                    ##
+                    # @return [String] Display name of the Language Operator describing its purpose.
+                    def display_name
+                        @properties['display_name']
+                    end
+                    
+                    ##
+                    # @return [String] Description of the Language Operator further explaining its purpose.
+                    def description
+                        @properties['description']
+                    end
+                    
+                    ##
+                    # @return [String] Numeric Operator version. Automatically incremented with each update on the resource, used to ensure integrity when updating the Operator.
+                    def version
+                        @properties['version']
+                    end
+                    
+                    ##
+                    # @return [OperatorAuthor] 
+                    def author
+                        @properties['author']
+                    end
+                    
+                    ##
+                    # @return [String] The natural language instructions used by the operator to analyze the conversation.  Within the prompt, users can reference parameters using the `{{parameters.[param_name]}}` syntax. Parameter values are provided to the Operator by the Intelligence Configuration Rule at runtime.  **Note**: Prompts will only be exposed for Custom Operators (`author` = `SELF`). Twilio-authored Operators (`author` = `TWILIO`) will have their prompts omitted from the API.
+                    def prompt
+                        @properties['prompt']
+                    end
+                    
+                    ##
+                    # @return [OperatorOutputFormat] 
+                    def output_format
+                        @properties['output_format']
+                    end
+                    
+                    ##
+                    # @return [Hash] Required for `JSON` output only. this will be set to a JSON Schema object describing the properties & data types of the response. Please see https://platform.openai.com/docs/guides/structured-outputs#supported-schemas   Will include the following keywords: - `type` : Must be set to `object` - `properties`:  An object containing the property names and their data types you would like the LLM to return  Additional details on JSON output formatting: - The root level `type` of a JSON schema must be set to `object` - The following property data types are supported : `string`, `number`, `boolean`, `integer`, `object`, `array`, `anyOf` - Definitions with `$defs` / `$ref` are supported - Max 100 object properties and 10 levels of nesting are supported - Max 1000 enum values across all enum properties are supported - Notable JSON Schema keywords not supported include:   - For `strings`: `minLength`, `maxLength`   - For `objects`: `patternProperties`, `unevaluatedProperties`, `propertyNames`, `minProperties`, `maxProperties`   - For `arrays`: `unevaluatedItems`, `contains`, `minContains`, `maxContains`, `uniqueItems` - Structured Operator Results will be returned in the same order as the ordering of keys in the schema - In the event an Operator execution request is refused for safety reasons the Operator Result API response will include a new field called `refusal` to indicate that the LLM refused to fulfill the request - Twilio will automatically set `additionalProperties` to false and specify all provided fields as required (constraints of Structured Outputs). You don't need to pass these fields as part of your JSON schema. Twilio will automatically overwrite any user-provided values for these fields.
+                    def output_schema
+                        @properties['output_schema']
+                    end
+                    
+                    ##
+                    # @return [Array<OperatorTrainingExample>] An array of example input/output pairs used to illustrate the intended behavior of the Language Operator. These examples help guide the model's understanding of expected input–output relationships and improve consistency during evaluation and testing.  **Note**: Training examples will only be exposed for Custom Operators (`author` = `SELF`). Twilio-authored Operators (`author` = `TWILIO`) will have their training examples omitted from the API.
+                    def training_examples
+                        @properties['training_examples']
+                    end
+                    
+                    ##
+                    # @return [OperatorContext] 
+                    def context
+                        @properties['context']
+                    end
+                    
+                    ##
+                    # @return [Hash<String, OperatorParameter>] Defines the schema of the parameters that are provided when running the operator, including required and optional values that determine the operator's behavior. The values of the parameters themselves are passed in by the attached Intelligence Configuration.
+                    def parameters
+                        @properties['parameters']
+                    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
+                    
+                    ##
+                    # Delete the OperatorInstance
+                    # @return [Boolean] True if delete succeeds, false otherwise
+                    def delete
+
+                        context.delete
+                    end
+
+                    ##
+                    # Fetch the OperatorInstance
+                    # @return [OperatorInstance] Fetched OperatorInstance
+                    def fetch
+
+                        context.fetch
+                    end
+
+                    ##
+                    # Update the OperatorInstance
+                    # @param [String] if_match Current ETag/version required for conditional update
+                    # @param [LanguageOperator] language_operator Full replacement of a Language Operator configuration
+                    # @return [OperatorInstance] Updated OperatorInstance
+                    def update(
+                      if_match: :unset,
+                      language_operator: nil
+                    )
+
+                        context.update(
+                            if_match: if_match, 
+                            language_operator: language_operator, 
+                        )
+                    end
+
+                    ##
+                    # Provide a user friendly representation
+                    def to_s
+                        values = @params.map{|k, v| "#{k}: #{v}"}.join(" ")
+                        "<Twilio.Intelligence.V3.OperatorInstance #{values}>"
+                    end
+
+                    ##
+                    # Provide a detailed, user friendly representation
+                    def inspect
+                        values = @properties.map{|k, v| "#{k}: #{v}"}.join(" ")
+                        "<Twilio.Intelligence.V3.OperatorInstance #{values}>"
+                    end
+                end
+
+            end
+        end
+    end
+end